synchronized的四种用法

同步锁

synchronized顾名思义，就是用来进行一些同步工作的，我们常常在多线程的环境中使用到它，实现互斥的效果。

每一个java对象都可以当做一个同步锁，线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得锁的唯一途径就是进入这个锁的保护的同步代码块或方法。这里的同步代码块和同步方法，就是使用synchronized关键字标记的代码块和方法。比如：

 

synchronized (object) {
    //doSomething...        
}

上面的 '{' '}' 中间的内容，就是同步代码块，object可以认为是同步锁。同步锁实现了互斥的效果，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的锁时，线程A必须等待或者阻塞，知道线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

synchronized修饰代码块

synchronized同步锁为普通对象

 

public void function(){
    synchronized (object) {
        //doSomething...        
    }
}

当某个线程要访问上面同步代码块中的内容时，若此时没有其他线程获得object对象的锁，则此线程获得object对象的锁，获得了这段代码的执行权，否则，此线程被阻塞，直到其他线程释放了object对象的锁。

下面的例子：

 

public class SyncTest {
    public static void main(String args[]){
        Sync[] syncs = new Sync[5];
        for (int i = 0; i < syncs.length; i++) {
            syncs[i] = new Sync(new Object());
        }
        
        for(Sync sync : syncs){
            sync.start();
        }
    }
}
class Sync extends Thread{
    Object syncObj;
    public Sync(Object syncObj) {
        this.syncObj = syncObj;
    }
    public void run(){
        synchronized (syncObj) {
            System.out.println(Thread.currentThread().getName()+"运行中...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"结束...");
        }
    }
}

运行结果：

 

Thread-0运行中...
Thread-1运行中...
Thread-2运行中...
Thread-3运行中...
Thread-4运行中...
Thread-1结束...
Thread-0结束...
Thread-3结束...
Thread-4结束...
Thread-2结束...

跟我们的预期不一样，这5个线程并没有按顺序执行，他们之间不是同步的。这是因为：5个线程中的syncObj并不是指向同一个对象，他们之间不存在同步锁的竞争，所以是非同步的。将程序改为：

 

public class SyncTest {
    public static void main(String args[]){
        Sync[] syncs = new Sync[5];
        Object object = new Object();
        for (int i = 0; i < syncs.length; i++) {
            syncs[i] = new Sync(object);
        }
        
        for(Sync sync : syncs){
            sync.start();
        }
    }
}
class Sync extends Thread{
    Object syncObj;
    public Sync(Object syncObj) {
        this.syncObj = syncObj;
    }
    public void run(){
        synchronized (syncObj) {
            System.out.println(Thread.currentThread().getName()+"运行中...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"结束...");
        }
    }
}

运行结果：

 

Thread-0运行中...
Thread-0结束...
Thread-4运行中...
Thread-4结束...
Thread-2运行中...
Thread-2结束...
Thread-3运行中...
Thread-3结束...
Thread-1运行中...
Thread-1结束...

5个线程达到了同步的效果。但是5个线程的执行顺序并不是固定的，这是编译时重排序造成的。

重点要理解：若想要多个线程同步，则这些线程必须竞争同一个同步锁。

synchronized同步锁为类

类也是一个对象，可以按照普通对象的方式去理解。他们的不同之处在于，普通对象作用于某个实例，而类对象作用于整个类。

将上面的例子修改一下：

 

public class SyncTest {
    public static void main(String args[]){
        Sync[] syncs = new Sync[5];
        for (int i = 0; i < syncs.length; i++) {
            syncs[i] = new Sync();
        }
        
        for(Sync sync : syncs){
            sync.start();
        }
    }
}
class Sync extends Thread{
    public void run(){
        synchronized (SyncTest.class) {
            System.out.println(Thread.currentThread().getName()+"运行中...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"结束...");
        }
    }
}

运行结果：

 

Thread-0运行中...
Thread-0结束...
Thread-3运行中...
Thread-3结束...
Thread-1运行中...
Thread-1结束...
Thread-4运行中...
Thread-4结束...
Thread-2运行中...
Thread-2结束...

这些线程同样实现了同步，因为他们的同步锁是同一个对象--SyncTest类对象。

需要注意的是，类对象锁和普通对象锁是两个不同的锁（即使这个对象是这个类的实例），他们之间互不干扰。

 

public class SyncTest {
    public static void main(String args[]){
        Sync[] syncs = new Sync[5];
        for (int i = 0; i < syncs.length; i++) {
            syncs[i] = new Sync();
        }
        Sync1 sync1 = new Sync1(new SyncTest());
        
        for(Sync sync : syncs){
            sync.start();
        }
        
        sync1.start();
    }
}
class Sync extends Thread{
    public void run(){
        synchronized (SyncTest.class) {
            System.out.println(Thread.currentThread().getName()+"运行中...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"结束...");
        }
    }
}

class Sync1 extends Thread{
    SyncTest syncTest;
    public Sync1(SyncTest syncTest){
        this.syncTest = syncTest;
    }
    public void run(){
        synchronized (syncTest) {
            System.out.println(Thread.currentThread().getName()+"运行中...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"结束...");
        }
    }
}

运行结果：

 

Thread-0运行中...
Thread-5运行中...
Thread-0结束...
Thread-5结束...
Thread-4运行中...
Thread-4结束...
Thread-2运行中...
Thread-2结束...
Thread-3运行中...
Thread-3结束...
Thread-1运行中...
Thread-1结束...

可以看到，虽然Sync1中的对象锁是SyncTest的实例，但是Sync1与Sync的run方法中的synchronized代码块并没有实现同步，他们可以同时访问这段代码。

synchronized修饰方法

synchronized修饰方法在本质上和修饰代码块是一样的，他们都是通过同步锁来实现同步的。

synchronized修饰普通方法

 

public synchronized void syncFunction(){
        //doSomething...
}

synchronized修饰普通方法中的同步锁就是这个对象本身，即"this"。

下面的代码：

 

class Sync extends Thread{
    public synchronized void syncFunction(){
        doSomething();
    }
    
    public void syncFunction2(){
        synchronized (this) {
            doSomething();
        }
    }
    
    private void doSomething(){
        //doSomething...
    }
}

上面syncFunction()与syncFunction2()实现的同步效果是一样的。

当类中某个方法test()被synchronized关键字所修饰时，所有不同的线程访问这个类的同一个实例的test()方法都会实现同步的效果。不同的实例之间不存在同步锁的竞争，也就是说，不同的线程访问这个类不同实例的test()方法并不会实现同步。这很容易理解，因为不同的实例同步锁不同，每个实例都有自己的"this"。

synchronized修饰静态方法

 

public static synchronized void syncFunction(){
        //doSomething...
}

同样的，synchronized作用于静态方法时，跟使用类对象作为静态锁的效果是一样的，此时的类对象就是静态方法所属的类。

不同的线程访问某个类不同实例的syncFunction()方法(被synchronized修饰的静态方法，如上)时，他们之间实现了同步效果。结合上面的解释，这种情况也很好理解：此时不同线程竞争同一把同步锁，这就是这个类的类对象锁。

总结

理解synchronized的关键就在于：若想要多个线程同步，则这些线程必须竞争同一个同步锁。这个同步锁，可以理解为一个对象。