Java多线程之二(Synchronized)

常用API

同步

上面已经介绍了比较常用的api，现在我们可以了解一下在多线程中占据着重要地位的锁了。

为什么会出现线程不安全

在上一篇文章中有提到在现在操作系统中进程是作为资源分配的基本单位，而线程是作为调度的基本单位，一般而言，线程自己不拥有系统资源，但它可以访问其隶属进程的资源，即一个进程的代码段、数据段及所拥有的系统资源，如已打开的文件、I/O设备等，可以供该进程中的所有线程所共享，一旦有多个线程在操作同样的资源就可能造成线程安全的问题。

在我们熟悉的Java中存在着局部变量和类变量，其中局部变量是存放在栈帧中的，随着方法调用而产生，方法结束就被释放掉，而栈帧是独属于当前线程的，所以不会有线程安全的问题。而类变量是被存放在堆内存中，可以被所有线程共享，所以也会存在线程安全的问题。

synchronized

在Java中我们见得最多的同步的方法应该就是使用synchronized关键字了。实际上synchronized就是一个互斥锁，当一个线程运行到使用了synchronized的代码段时，首先检查当前资源是否已经被其他线程所占用，如果已经被占用，那么该线程则阻塞在这里，直到拥有资源的线程释放锁，其他线程才可以继续申请资源。

实现简单理解

public static void test(){
    synchronized (SyncDemo.class){
    }
}

//编译后的代码
  public static void test();
    Code:
       0: ldc           #3                  //将一个常量加载到栈中这里既是class com/learn/set/mutilthread/sync/SyncDemo
       2: dup               //复制栈顶元素(SyncDemo.class)
       3: astore_0          //将栈顶元素存储到局部变量表
       4: monitorenter      //以字节码对象(SyncDemo.class)为锁开始同步操作
       5: aload_0           //将局部变量表slot_0入栈(SyncDemo.class)
       6: monitorexit       //退出同步
       7: goto          15  //到这里程序跳转到return语句正常结束，下面代码是异常路径
      10: astore_1
      11: aload_0
      12: monitorexit
      13: aload_1
      14: athrow
      15: return

到这里就差不多了，详细的原理后面再谈，这里主要是谈谈synchronized的使用。

synchronized的使用

在Java语言中，synchronized关键字可以用来修饰方法以及代码块：

修饰方法

    //修饰普通方法
    public synchronized void say(){

    }
    //修饰静态方法
    public synchronized static void fun(){

    }

修饰代码块

    public void fun1(){
        //使用当前对象为锁
        synchronized (this){
            //statement
        }
    }

    public void fun2(){
        //使用当前类字节码对象为锁
        synchronized (SyncDemo.class){
            //statement
        }
    }

synchronized在不同场景下的区别

实体类：

public class User {
    private static int age = 20;

    public synchronized void say(String user) throws InterruptedException {
//        synchronized (User.class){
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
        //当前线程休眠，判断别的线程是否还能调用
        Thread.sleep(1000);
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
//        }
    }

    public synchronized void say1(String user) throws InterruptedException {
//        synchronized (User.class){
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
        Thread.sleep(1000);
        age = 15;
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
//        }
    }
}

测试类：

public class SyncTest{
    private static User user1 = new User();
    private static User user2 = new User();

    private static class Sync1 extends Thread{
        @Override
        public void run() {
            try {
                user1.say("user1");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class Sync2 extends Thread{
        @Override
        public void run() {
            try {
                user2.say("user2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Sync1 sync1 = new Sync1();
        Sync2 sync2 = new Sync2();
        sync1.start();
        sync2.start();
    }
}
运行结果：
第一次运行：
20:Thread-1:user2
20:Thread-0:user1
20:Thread-0:user1
20:Thread-1:user2
第二次运行：
20:Thread-1:user2
20:Thread-0:user1
20:Thread-1:user2
20:Thread-0:user1

运行结果表示在普通方法上加synchronized关键字实际上是锁的当前对象，所以不同线程操作不同对象结果可能出现不一致。修改实体类User的say(...)方法为静态方法：

public synchronized void say(String user) throws InterruptedException {
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
        Thread.sleep(1000);
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
    }

运行结果始终按照顺序来：

20:Thread-0:user1
20:Thread-0:user1
20:Thread-1:user2
20:Thread-1:user2

说明在静态(类)方法上加synchronized关键字实际上是锁的当前类的字节码对象，因为在JVM中任何类的字节码对象都只有一个，所以只要对该字节码对象加锁那么任何对该类的操作也都是同步的。

在最初类的基础上修改类Sync2，使得两个线程操作统一对象：

private static class Sync2 extends Thread{
        @Override
        public void run() {
            try {
                user1.say("user2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

运行结果始终按照顺序来：

20:Thread-0:user1
20:Thread-0:user1
20:Thread-1:user2
20:Thread-1:user2

同理可测试在使用synchronized修饰代码块的作用，可得结果使用this对象实际是锁当前对象，与synchronized修饰普通方法类似，使用User.class字节码对象实际是锁User类的字节码对象，与synchronized修饰静态方法类似。需要说明的事锁代码块实际上并不是必须使用当前类的this对象和字节码对象，而可以是任意的对象。而实际效果和使用当前类的对象一致。

原文地址：https://www.cnblogs.com/liyus/p/9979270.html