Java多线程（四） 解决多线程安全——synchronized

Java多线程（四） 解决多线程安全——synchronized

在上一篇文章 《Java多线程（三） 多线程不安全的典型例子》中说到了多线程不安全的问题以及三个典型例子，在这一篇中讲解一中保证多线程安全的一种方式——synchronized关键字。

synchronized的使用

synchronized相当于给对象上锁或者给类上锁，这样防止其他线程访问共享资源，进而保护多线程的安全。synchronized的原理是它使用了flag标记ACC_SYN-CHRONIZED，执行线程先持有同步锁，然后执行方法，最后在方法完成时才释放锁。

synchronized主要有三种用法：

1. 修饰实例方法：作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁。

synchronized void method() {
  //业务代码
}

2. 修饰静态方法：也就是给当前类加锁，会作用于类的所有对象实例 ，进入同步代码前要获得当前 class 的锁。因为静态成员不属于任何一个实例对象，是类成员（ static 表明这是该类的一个静态资源，不管 new 了多少个对象，只有一份），所以，如果一个线程 A 调用一个实例对象的非静态 synchronized 方法，而线程 B 需要调用这个实例对象所属类的静态 synchronized 方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的锁，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。

synchronized void staic method() {
  //业务代码
}

3. 修饰代码块：指定加锁对象，对给定对象/类加锁。synchronized(this / object) 表示进入同步代码库前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得当前 class 的锁

synchronized(this) {
  //业务代码
}

总的来说：

synchronized 关键字加到 static 静态方法和 synchronized(class) 代码块上都是是给 Class 类上锁。

synchronized 关键字加到实例方法上是给对象实例上锁。

synchronized 是重量型锁

Synchronized是通过对象内部的一个叫做监视器锁（monitor）来实现的。但是监视器锁本质又是依赖于底层的操作系统的Mutex Lock来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到核心态，这个成本非常高，状态之间的转换需要相对比较长的时间，这就是为什么Synchronized效率低的原因。因此，这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。

synchronized 原理和例子

在 Java 中，synchronized可以保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，此外synchronized的另外一个重要的作用是synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到（保证可见性，完全可以替代Volatile功能），这点确实也是很重要的。

synchronized 作用于实例方法

第一个例子举一个很简单的对一个类的共享资源加一的操作，为了保证多线程安全，使用synchronized修饰increase()。对于增加i值来说，他并不是一个原子操作，因为第一步要读取i值，第二步要对他进行加一操作，因此需要进行互斥操作。synchronized修饰的是实例方法increase，在这样的情况下，当前线程的锁便是实例对象instance。当一个线程正在访问一个对象的 synchronized 实例方法，那么其他线程不能访问该对象的所有 synchronized 方法，因为一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的synchronized实例方法，这样的方式也就保护了多线程的安全，不过其他线程还是可以访问该实例对象的其他非synchronized方法。

public class syntest {

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

class AccountingSync implements Runnable{
    static int i=0;

    public synchronized void increase() throws InterruptedException {
        i++;
        Thread.sleep(300);
        System.out.println(Thread.currentThread().getName()+"增加了i值，它的值为 "+i);
    }
    @Override
    public void run() {
        for(int j=0;j<100;j++){
            try {
                increase();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

（省略中间的）

synchronized 作用于代码块

这里举的例子是上一篇《Java多线程（三） 多线程不安全的典型例子》的第一个不安全的买票例子，这里依旧是三个人买票，一共三十张票，不同的是这次使用synchronized对买票的代码块进行上锁。当编写的方法体比较大时，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，如果直接对整个方法进行同步操作，可能会得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了。将synchronized作用于一个给定的实例对象t，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待。当然除了t作为对象外，我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁。

class Ticket implements Runnable{

    private int alltickets = 30;
    private boolean flag = true;

    @Override
    public void run() {
        while(alltickets>0) {
                synchronized (this) {
                    try {
                        Thread.sleep(300);
                        buy();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

        }
    }

    public void buy() throws InterruptedException {

        if(this.alltickets<=0)
        {
            System.out.println("没票可买了"+Thread.currentThread().getName());
            this.flag = false;
            return;
        }

        else
        {
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName()+"买了第"+this.alltickets--+"张票   ");

        }
    }

}

public class testThread {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Ticket t = new Ticket();
        new Thread(t, "小华同学").start();
        new Thread(t, "小明同学").start();
        new Thread(t, "黄牛").start();
        }

可以看到这次买票过程是有序的，并且没有出现买到重复票的问题

synchronized作用于静态方法

当synchronized作用于静态方法时，其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static的synchronized方法，而线程B需要调用这个实例对象所属类的静态 synchronized方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的class对象，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。synchronized关键字修饰的是静态方法，其锁对象是当前类的class对象。注意代码中的increase2方法是实例方法，其对象锁是当前实例对象，如果别的线程调用该方法，将不会产生互斥现象，毕竟锁对象不同，但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。

public class syntest {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(new StaticTest());
        Thread t2=new Thread(new StaticTest());
        t1.start();t2.start();
        
    }
}

class StaticTest implements Runnable{
    static int i=0;

    /**
     * 作用于静态方法,锁是当前class对象,也就是StaticTest类对应的class对象
     */
    public static synchronized void increase() throws InterruptedException {
        i++;
        Thread.sleep(300);
        System.out.println(Thread.currentThread().getName()+"增加了i值，它的值为 "+i);
    }

    /**
     * 非静态,访问时锁不一样不会发生互斥
     */
    public synchronized void increase2(){
        i++;
    }

    @Override
    public void run() {
        for(int j=0;j<100;j++){
            try {
                increase();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

synchronized 可重入锁

关键字synchronized拥有重入锁的功能，即在使用synchronized时，当一个线程得到了一个对象锁后，再次请求此对象锁时是可以得到该对象锁的，意思是在一个synchronized方法或者代码块中，调用这个类的其他synchronized方法或者代码块时是可以做到的。

public class syntest {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new Thread(new StaticTest());

        t1.start();

    }
}

class StaticTest implements Runnable{
    public synchronized void method1()
    {
        System.out.println("method1");
        method2();
    }

    public synchronized void method2()
    {
        System.out.println("method2");
        method3();
    }

    public synchronized void method3()
    {
        System.out.println("method3");
    }


    @Override
    public void run() {
        method1();
    }
}