线程同步总结--synchronized方法和synchronized代码块

阅读前必须明白：

程序代码的目的是操作数据，而在操作数据时有可能发生同时操作同一个数据，所以为了避免同时操作一个数据产生错误才出现线程同步的概念，即synchronized方法和synchronized代码块技术。

这里的同一个数据包括 所有对象...

还有每一个对象都有一把锁，synchronized就是为此对象上锁，等到synchronized方法或synchronized代码块执行完就会自动解锁，所有多线程执行相同带synchronized的代码时会检查所操作对象是否上锁，如果已经被锁住，就阻塞等待，直到锁此代码段的线程执行完此代码块。

所以非synchronized方法不会有阻塞一说，因为它没有synchronized，所以不会检查对象锁住没有

 

 若想深入了解对象锁机制，参考http://zhangjunhd.blog.51cto.com/113473/70300

 

synchronized方法和synchronized代码块的理解：

synchronized方法锁住的是this，

synchronized(this){ }，锁住this，只要多个线程同时访问同一个SynchronizedTest实例（this），就会发生不能同时访问此代码块
synchronized(Object){ }，锁住Object，只要多个线程同时访问同一个Object就会发生不能同时访问此代码块

 

同步的目的就避免操作同一个数据，所以操作不同数据就不必要同步。

理解下面代码的区别，就真正理解了同步：

public class SynchronizedTest{
	
	Person p = new Person("lin", 15);
	
	public synchronized void say(){//相当于锁住this，效果和say3()一样，只要多个线程同时访问同一个SynchronizedTest实例（相当于this），就会发生不能同时访问此方法
		System.out.println(p.getName());
	}
	
	public void say2(){
		synchronized(p){//相当于锁住p，只要多个线程同时访问此代码块且是同一个p，就会发生不能同时访问此代码块锁住
			System.out.println(p.getName());
		}
	}
	
	public void say3(){
		synchronized(this){//锁住this，效果和say()一样，只要多个线程同时访问同一个SynchronizedTest实例（this），就会发生不能同时访问此代码块
			System.out.println(p.getName());
		}
	}
}

 

 

 

明白则一点，就阅读下面：

我就偷点懒，摘抄一下别人的，其实人家和我要写的差不多

以下摘自http://blog.csdn.net/xiao__gui/article/details/8188833

在Java中，synchronized关键字是用来控制线程同步的，就是在多线程的环境下，控制synchronized代码段不被多个线程同时执行。Synchronized既可以对代码块使用，也可以加在整个方法上。

 

关键是，不要认为给方法或者代码段加上synchronized就万事大吉，看下面一段代码：

class Sync {

    public synchronized void test() {
        System.out.println("test开始..");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test结束..");
    }
}

class MyThread extends Thread {

    public void run() {
        Sync sync = new Sync();
        sync.test();
    }
}

public class Main {

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread();
            thread.start();
        }
    }
}

 

运行结果：

test开始..

test开始..

test开始..

test结束..

test结束..

test结束..

 

可以看出来，上面的程序起了三个线程，同时运行test方法，虽然test方法加上了synchronized，但是还是同时运行起来，貌似synchronized没起作用。

 

将test方法改成如下：

public void test() {
    synchronized(this){
        System.out.println("test开始..");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test结束..");
    }
}

 

运行结果：

test开始..

test开始..

test开始..

test结束..

test结束..

test结束..

 

一切还是这么平静，没有看到synchronized起到一丝作用。

 

实际上，synchronized(this)以及非static的synchronized方法（至于static synchronized方法请往下看），只能防止多个线程同时执行同一个对象的这个代码段。

 

为什么会这样呢，回到本文的题目上：Java线程同步：synchronized锁住的是代码还是对象。答案是：synchronized锁住的是括号里的对象，而不是代码。对于非静态的synchronized方法，锁的就是对象本身也就是this。

 

当synchronized锁住一个对象后，别的线程如果也想拿到这个对象的锁，就必须等待这个线程执行完成释放锁，才能再次给对象加锁，这样才达到线程同步的目的。

 

所以我们在用synchronized关键字的时候，能缩小代码段的范围就尽量缩小，能在代码段上加同步就不要再整个方法上加同步。这叫减小锁的粒度，使代码更大程度的并发。原因是基于以上的思想，锁的代码段太长了，别的线程是不是要等很久，等的花儿都谢了。当然这段是题外话，与本文核心思想并无太大关联。

 

再看上面的代码，每个线程中都new了一个Sync类的对象，也就是产生了三个Sync对象，由于不是同一个对象，所以可以多线程同时运行synchronized方法或代码段。

 

为了验证上述的观点，修改一下代码，让三个线程使用同一个Sync的对象。

class MyThread extends Thread {

    private Sync sync;

    public MyThread(Sync sync) {
        this.sync = sync;
    }

    public void run() {
        sync.test();
    }
}

public class Main {

    public static void main(String[] args) {
        Sync sync = new Sync();
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread(sync);
            thread.start();
        }
    }
}

 

运行结果：

test开始..

test结束..

test开始..

test结束..

test开始..

test结束..

 

可以看到，此时的synchronized方法和synchronized代码段就都起了作用。

 

那么，如果真的想锁住这段代码，要怎么做？也就是，如果还是最开始的那段代码，每个线程new一个Sync对象，怎么才能让test方法不会被多线程执行。

 

解决也很简单，只要锁住同一个对象不就行了。例如，synchronized后的括号中锁一个static final对象，这样就行了。这样是没问题，但是，比较多的做法是让synchronized锁这个类对应的Class对象。

class Sync {

    public void test() {
        synchronized (Sync.class) {
            System.out.println("test开始..");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("test结束..");
        }
    }
}

class MyThread extends Thread {

    public void run() {
        Sync sync = new Sync();
        sync.test();
    }
}

public class Main {

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            Thread thread = new MyThread();
            thread.start();
        }
    }
}

 

运行结果：

test开始..

test结束..

test开始..

test结束..

test开始..

test结束..

 

上面代码用synchronized(Sync.class)实现了全局锁的效果。

 

最后说说static synchronized，实际上static方法可以直接类名加方法名调用，方法里面没有this这个概念，所以，static synchronized方法也相当于全局锁，相当于锁住了代码段。