初探synchronized

初探synchronized

我们还是按部就班地进行wwh：

• 什么是synchronized（what）
• 为什么使用synchronized（why）
• 如何使用synchronized（how）

---

什么是synchronized

Java语言的关键字，可用来给对象和方法或者代码块加锁。

为什么使用synchronized

当使用synchronized关键字来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。

如何使用synchronized

我们由一个问题引出，看看下面例子：为了让静态变量 i 随线程顺序输出

1.非synchronized方式，使用了Thread.join()方法，代码如下：

package com.feiniu.yp;

public class SyncDemo implements Runnable{

    static int i = 1;

    @Override
    public void run() {
        for (int j = 0; j < 5; j++) {
            System.out.println(Thread.currentThread().getName() + "-" + i++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new SyncDemo(),"t1");
        Thread t2 = new Thread(new SyncDemo(),"t2");
        t1.start();
        t1.join();
        t2.start();
        t2.join();
    }
}

控制台按顺序输出

t1-1
t1-2
t1-3
t1-4
t1-5
t2-6
t2-7
t2-8
t2-9
t2-10

2.在方法上使用synchronized方式，代码如下：

package com.feiniu.yp;

public class SyncDemo implements Runnable{

    static int i = 1;

    @Override
    public synchronized void run() {
        for (int j = 0; j < 5; j++) {
            System.out.println(Thread.currentThread().getName() + "-" + i++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new SyncDemo(),"t1");
        Thread t2 = new Thread(new SyncDemo(),"t2");
        t1.start();
        t2.start();
    }
}

控制台不是顺序，多次执行随机输出

t1-1
t2-2
t1-3
t2-4
t1-5
t2-6
t1-7
t2-8
t1-9
t2-10

从控制台输出结果来看synchronized关键字并没有启到作用，我们可以看到在线程t1和线程t2分别进行new SyncDemo()创建对象，这时简单理解就是线程t1获取了一把属于t1的锁，线程t2获取了一把属于t2的锁，就比如一个仓库开了两扇门，t1进入A门，t2进入B门，毫无先后关系。

3.在方法上使用synchronized方式，调用方式使用同一个对象，代码如下：

package com.feiniu.yp;

public class SyncDemo implements Runnable{

    static int i = 1;

    @Override
    public synchronized void run() {
        for (int j = 0; j < 5; j++) {
            System.out.println(Thread.currentThread().getName() + "-" + i++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SyncDemo sync = new SyncDemo();
        Thread t1 = new Thread(sync,"t1");
        Thread t2 = new Thread(sync,"t2");
        t1.start();
        t2.start();
    }
}

控制台顺序输出

t1-1
t1-2
t1-3
t1-4
t1-5
t2-6
t2-7
t2-8
t2-9
t2-10

控制台输出结果是顺序的，看来synchronized关键生效了（其实案例2是生效的），与案例2唯一的区别在于线程t1和线程t2使用了同一个对象sync，相当于t1获取了对象sync（锁），t2属于等待状态，等t1执行完，t2再获取对象sync（锁），继续执行t2。所以输出结果有序。

4.在代码块上使用synchronized方式，代码如下：

package com.feiniu.yp;

public class SyncDemo implements Runnable{

    static int i = 1;

    @Override
    public void run() {
        synchronized (SyncDemo.class) {
            for (int j = 0; j < 5; j++) {
                System.out.println(Thread.currentThread().getName() + "-" + i++);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new SyncDemo(),"t1");
        Thread t2 = new Thread(new SyncDemo(),"t2");
        t1.start();
        t2.start();
    }
}

package com.feiniu.yp;

public class SyncDemo implements Runnable{

    static int i = 1;

    @Override
    public void run() {
        synchronized (SyncDemo.class) {
            for (int j = 0; j < 5; j++) {
                System.out.println(Thread.currentThread().getName() + "-" + i++);
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SyncDemo sync = new SyncDemo();
        Thread t1 = new Thread(sync,"t1");
        Thread t2 = new Thread(sync,"t2");
        t1.start();
        t2.start();
    }
}

控制台顺序输出：

t1-1
t1-2
t1-3
t1-4
t1-5
t2-6
t2-7
t2-8
t2-9
t2-10

代码块里使用synchronized入参为SyncDemo.class，java文件最终会生成class文件，SyncDemo.class相当于原件，new SyncDemo() 相当于副本。

无论是new对象方式调用

Thread t1 = new Thread(new SyncDemo(),"t1");
Thread t2 = new Thread(new SyncDemo(),"t2");

还是同一个对象方式调用

SyncDemo sync = new SyncDemo();
Thread t1 = new Thread(sync,"t1");
Thread t2 = new Thread(sync,"t2");

new对象方式调用和对象方式调用，调用到synchronized (SyncDemo.class) ，主要是代码块这里上锁了，跟调用方式无关。