java静态同步方法

A. java中实现同步的两种方式syschronized和lock的区别和联系

Lock是java.util.concurrent.locks包下的接口，Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题，我们拿Java线程(二)中的一个例子简单的实现一下和sychronized一样的效果，代码如下：

[java]view plain

从结果可以看出实现了我们的需求，这只是锁的基本用法，锁的机制还需要继续深入学习。

本文来自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/7461369，转载请注明。

在java中有两种方式实现原子性操作（即同步操作）：
1）使用同步关键字synchronized
2）使用lock锁机制其中也包括相应的读写锁

package com.xiaohao.test;

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test {
public static void main(String[] args) {
final LockTest lock=new LockTest();
//输出张三
new Thread(){
public void run(){
lock.test("张三张三张三张三张三张三张三张三张三张三");
}
}.start();

//输出李四
new Thread(){
public void run(){
lock.test("李四李四李四李四李四李四李四李四李四李四");System.out.println
(" ---------------------------------------------------------------");
}
}.start();


//---------------------------------------------------------------
//模拟写入数据的
for (int i = 0; i < 3; i++) {
new Thread(){
public void run() {
for (int j = 0; j < 5; j++) {
// lock.set(new Random().nextInt(30));
lock.set2(new Random().nextInt(30));

}
}
}.start();

}
//模拟读取数据的
for (int i = 0; i < 3; i++) {
new Thread(){
public void run() {
for (int j = 0; j < 5; j++) {
// lock.get();
lock.get2();
}
}
}.start();
}


}
}

class LockTest{
private Lock lock=new ReentrantLock(); //创建普通的锁
private ReadWriteLock readWriteLock=new ReentrantReadWriteLock();//创建读写锁
private int data;// 共享数据


//实现同步的方法一 使用同步关键字 synchronized
public synchronized void test(String name){
//下面的相关操作是一个原子性的操作
// lock.lock();// 得到锁
try {
for(int i = 0; i < name.length(); i++) {
System.out.print(name.charAt(i));
}
} finally {
// lock.unlock();// 释放锁
}
}
//实现同步的方法二 使用lock锁机制
public void test2(String name){
//下面的相关操作是一个原子性的操作
lock.lock();// 得到锁
try {
for(int i = 0; i < name.length(); i++) {
System.out.print(name.charAt(i));
}
} finally {
lock.unlock();// 释放锁
}
}


//使用set方法模拟写入数据
//使用 synchronized 实现了读读，写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的
public synchronized void set(int data){
System.out.println(Thread.currentThread().getName() + "准备写入数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入" + this.data);
}

//使用get方法模拟读取数据
//使用 synchronized 实现了读读，写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的
public synchronized void get() {
System.out.println(Thread.currentThread().getName() + "准备读取数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "读取" + this.data);
}


//使用set方法模拟写入数据
//使用 读写锁实现了写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的
public void set2(int data){
readWriteLock.writeLock().lock();//获取写入锁
try{
System.out.println(Thread.currentThread().getName() + "准备写入数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.data = data;
System.out.println(Thread.currentThread().getName() + "写入" + this.data);
}
finally{
readWriteLock.writeLock().unlock();
}
}


//使用get方法模拟读取数据
//使用 读写锁实现了写写，读写之间的互斥 ，但读读之间的互斥是没有什么必要的
public void get2() {
//获取相应的读锁
readWriteLock.readLock().lock();
try{
System.out.println(Thread.currentThread().getName() + "准备读取数据");
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "读取" + this.data);
}
finally{
// 释放相应的写锁
readWriteLock.readLock().unlock();
}
}

}

线程同步经典版：

package com.xiaohao.test;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class Test2{

public static void main(String[] args){

final LockTest2 lockTest=new LockTest2();

for(int i=0;i<3;i++) {

new Thread(){

public void run(){

try {

for (int j = 0; j < 3; j++) {

lockTest.setValue();

} } catch (InterruptedException e) {

// TODO Auto-generated catch block e.printStackTrace();

}

}

}.start();

}

for(int i=0;i<3;i++) {

new Thread(){

public void run(){

try {

for (int j = 0; j < 3; j++) {

lockTest.getValue();

}

} catch (InterruptedException e)

{ // TODO Auto-generated catch block e.printStackTrace(); }

}

}.start();

}

}

}

class LockTest2 {

int data=0;

ReentrantReadWriteLock lock= new ReentrantReadWriteLock();// 锁对象

public void setValue() throws InterruptedException{

lock.writeLock().lock();

System.out.println("正在使用写锁......");

data=(int) (Math.random()*10);

System.out.println("正在写入："+data);

Thread.sleep(500);

System.out.println("写锁调用完毕---------------------------");

lock.writeLock().unlock(); }

public void getValue() throws InterruptedException{

lock.readLock().lock();

System.out.println("正在使用读锁...........................................");

System.out.println("正在读入："+data); Thread.sleep(500);

System.out.println("读锁调用完毕......");

lock.readLock().unlock();

}

}

**** 当一个线程进入了一个对象是的synchronized方法，那么其它线程还能掉否调用此对象的其它方法？

这个问题需要分几种情况进行讨论。

1）查看其它方法是否使用了同步关键字(synchronized)修饰，如果没有的话就可以调用相关的方法。

2）在当前synchronized方法中是否调用了wait方法，如果调用了，则对应的锁已经释放，可以访问了。

3）如果其它方法也使用synchronized修饰，并且当前同步方法中没有调用wait方法的话，这样是不允许访问的。

4）如果其它方法是静态方法的话，由于静态方法和对象是扯不上什么关系，对于静态同步方法而言，其对应的同步监视器为当前类的字节码

所以肯定可以访问的了。

B. java 总结几种线程异步转同步的方法

以Java语言为例：
用synchronized关键字修饰同步方法。
同步有几种实现方法分别是synchronized,wait与notify
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。
给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。下面代码是一个同步方法的示例：
public synchronized void aMethod() {
// do something
}
public static synchronized void anotherMethod() {
// do something
}

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有异步方法的。
同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

C. java中同步有几种方式啊

1。同步代码块：
synchronized(同一个数据){} 同一个数据：就是N条线程同时访问一个数据。
2。
同步方法：
public synchronized 数据返回类型 方法名(){}
就
是使用 synchronized 来修饰某个方法，则该方法称为同步方法。对于同步方法而言，无需显示指定同步监视器，同步方法的同步监视器是
this
也就是该对象的本身（这里指的对象本身有点含糊，其实就是调用该同步方法的对象）通过使用同步方法，可非常方便的将某类变成线程安全的类，具有如下特征：
1，该类的对象可以被多个线程安全的访问。
2，每个线程调用该对象的任意方法之后，都将得到正确的结果。
3，每个线程调用该对象的任意方法之后，该对象状态依然保持合理状态。
注：synchronized关键字可以修饰方法，也可以修饰代码块，但不能修饰构造器，属性等。
实现同步机制注意以下几点： 安全性高，性能低，在多线程用。性能高，安全性低，在单线程用。
1，不要对线程安全类的所有方法都进行同步，只对那些会改变共享资源方法的进行同步。
2，如果可变类有两种运行环境，当线程环境和多线程环境则应该为该可变类提供两种版本：线程安全版本和线程不安全版本(没有同步方法和同步块)。在单线程中环境中，使用线程不安全版本以保证性能，在多线程中使用线程安全版本.

线程通讯：
为什么要使用线程通讯？
当
使用synchronized
来修饰某个共享资源时(分同步代码块和同步方法两种情况）,当某个线程获得共享资源的锁后就可以执行相应的代码段，直到该线程运行完该代码段后才释放对该

共享资源的锁，让其他线程有机会执行对该共享资源的修改。当某个线程占有某个共享资源的锁时，如果另外一个线程也想获得这把锁运行就需要使用wait()
和notify()/notifyAll()方法来进行线程通讯了。
Java.lang.object 里的三个方法wait() notify() notifyAll()
wait方法导致当前线程等待，直到其他线程调用同步监视器的notify方法或notifyAll方法来唤醒该线程。
wait(mills)方法
都是等待指定时间后自动苏醒，调用wait方法的当前线程会释放该同步监视器的锁定，可以不用notify或notifyAll方法把它唤醒。
notify()
唤醒在同步监视器上等待的单个线程，如果所有线程都在同步监视器上等待，则会选择唤醒其中一个线程，选择是任意性的，只有当前线程放弃对该同步监视器的锁定后，也就是使用wait方法后，才可以执行被唤醒的线程。
notifyAll()方法
唤醒在同步监视器上等待的所有的线程。只用当前线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程

D. java synchronized同步静态方法和同步非静态方法的区别与举例

同步静态方法是对对应类的Class类加锁，这样的话，所有被synchronized修饰的静态方法同一时刻只能有一个被调用。同步非静态方法的话，它锁的是对应的示例，并不影响其他示例。

E. java同步代码块和同步方法的区别

1. 语法不同。
2. 同步块需要注明锁定对象，同步方法默认锁定this。
3. 在静态方法中，都是默认锁定类对象。
4. 在考虑性能方面，最好使用同步块来减少锁定范围提高并发效率。

F. java中同步的几种方法

Java的同步可以用synchronized关键字来实现。

sychronized可以同步代码，需要绑定一个对象，如synchronized(obj){}
也可以同步一个方法，是对方法进行线程同步。如public void synchronized methodA(){}

G. java synchronized同步静态方法和同步非静态方法的异同

所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。
而所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

H. java语言同步问题，为什么这样写就锁不住了 谢谢各路大神解答！

你写的方法的锁对象是当前对象.也就是说TR1线程的锁是TR1这个对象,TR2线程的锁是TR2这个对象,2个线程互不干扰

你可以参数如下信息:

详细解说一下同步方法的锁，同步方法分为静态同步方法与非静态同步方法。

所有的非静态同步方法用的都是同一把锁——实例对象本身，也

就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同

步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

而所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们同一个类的实例对象！

而对于同步块，由于其锁是可以选择的，所以只有使用同一把锁的同步块之间才有着竞态条件，这就得具体情况具体分析了，但这里有个需要注意的地方，同步块的锁是可以选择的，但是不是可以任意选择的！！！！这里必须要注意一个物理对象和一个引用对象的实例变量之间的区别！使用一个引用对象的实例变量作为锁并不是一个好的选择，因为同步块在执行过程中可能会改变它的值，其中就包括将其设置为null，而对一个null对象加锁会产生异常，并且对不同的对象加锁也违背了同步的初衷！这

看起来是很清楚的，但是一个经常发生的错误就是选用了错误的锁对象，因此必须注意：同步是基于实际对象而不是对象引用的！多个变量可以引用同一个对象，变

量也可以改变其值从而指向其他的对象，因此，当选择一个对象锁时，我们要根据实际对象而不是其引用来考虑！作为一个原则，不要选择一个可能会在锁的作用域

中改变值的实例变量作为锁对象！！！！

I. java 方法同步

设置三个同步变量不就完了，然后synchronized的时候就同步这三个变量区分就行了

J. Java实现同步的几种方式

应该是同步方法和同步代码块。
synchronized,wait与notify 这几个是实现同步的进一步细节操作，如果不是为了实现什么多线程明细，就简单的同步方法和同步代码块即可解决同步问题。