Java并发基础--线程安全

一、线程安全

1.线程安全的概念

线程安全：某个类被单个线程，或者多个线程同时访问，所表现出来的行为是一致，则可以说这个类是线程安全的。

2.什么情况下会出现线程安全问题

在单线程中不会出现线程安全问题，在多线程编程的情况下，并且多个线程访问同一资源的情况下可能出现线程安全问题。如下面的例子，出现典型的线程安全问题：

public class BookSaleRunable implements Runnable{
    private int bookNum=10;//书的总数为10
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            if(bookNum>0){
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+" 卖出一本书,剩余书籍:"+(--bookNum));
            }
        }
        
    }
    
    public static void main(String[] args) {
        BookSaleRunable booksr = new BookSaleRunable();
        //开启3个线程
        Thread t1 = new Thread(booksr);
        Thread t2 = new Thread(booksr);
        Thread t3 = new Thread(booksr);
        t1.start();
        t2.start();
        t3.start();
    }

}

结果输出：

Thread-1 卖出一本书,剩余书籍:9
Thread-2 卖出一本书,剩余书籍:7
Thread-0 卖出一本书,剩余书籍:8
Thread-1 卖出一本书,剩余书籍:6
Thread-0 卖出一本书,剩余书籍:4
Thread-2 卖出一本书,剩余书籍:5
Thread-1 卖出一本书,剩余书籍:3
Thread-2 卖出一本书,剩余书籍:1
Thread-0 卖出一本书,剩余书籍:2
Thread-2 卖出一本书,剩余书籍:0
Thread-1 卖出一本书,剩余书籍:-1
Thread-0 卖出一本书,剩余书籍:-2

上例出现超卖现象，在生活中不允许，同时如果是一个线程肯定不会出现。那么如何解决这个问题呢？基本上所有的并发模式在解决线程冲突问题的时候，都是采用序列化访问共享资源的方案，在给定时刻只允许一个任务访问共享资源。

二、解决线程安全问题的方法

1.synchronized关键字

synchronized，顾名思义就是同步的意思，主要用来给方法、代码块加锁。当某个方法或者代码块使用synchronized时，那么在同一时刻至多仅有有一个线程在执行该段代码。当有多个线程访问同一对象的加锁方法/代码块时，同一时间只有一个线程在执行，其余线程必须要等待当前线程执行完之后才能执行该代码段。但是，其余线程是可以访问该对象中的非加锁代码块的。synchronized可以用来修饰方法和代码块。

synchronized修饰方法

当synchronized关键字修饰方法的时候，这个方法我们称为同步方法，同步方法可以控制对类成员变量的方法，synchronized关键字表明方法已经加锁，当任意一个线程访问同步方法的时候都必须 判断这个方法是否被其他线程独占。所有对象自动含有单一的锁，当在对象上调用其任意的synchronized方法的时候，次对象被加锁，这个时候这个对象的其他synchronized方法必须等到前一个同步方法调用完毕并释放锁之后才能被调用。如下：

public class BookSaleRunable2 implements Runnable{
    private int bookNum=20;//书的总数为10
    @Override
    public void run() {
        for(int i=0;i<7;i++){
            saleBook();
        }
        
    }
    
    public static void main(String[] args) {
        BookSaleRunable2 booksr = new BookSaleRunable2();
        //开启3个线程
        Thread t1 = new Thread(booksr);
        Thread t2 = new Thread(booksr);
        Thread t3 = new Thread(booksr);
        t1.start();
        t2.start();
        t3.start();
    }
    
    private synchronized void saleBook(){
        if(bookNum>0){
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+" 卖出一本书,剩余书籍:"+(--bookNum));
        }
    }

}

结果输出：

Thread-0 卖出一本书,剩余书籍:19
Thread-0 卖出一本书,剩余书籍:18
Thread-0 卖出一本书,剩余书籍:17
Thread-0 卖出一本书,剩余书籍:16
Thread-0 卖出一本书,剩余书籍:15
Thread-0 卖出一本书,剩余书籍:14
Thread-0 卖出一本书,剩余书籍:13
Thread-2 卖出一本书,剩余书籍:12
Thread-2 卖出一本书,剩余书籍:11
Thread-2 卖出一本书,剩余书籍:10
Thread-2 卖出一本书,剩余书籍:9
Thread-2 卖出一本书,剩余书籍:8
Thread-2 卖出一本书,剩余书籍:7
Thread-2 卖出一本书,剩余书籍:6
Thread-1 卖出一本书,剩余书籍:5
Thread-1 卖出一本书,剩余书籍:4
Thread-1 卖出一本书,剩余书籍:3
Thread-1 卖出一本书,剩余书籍:2
Thread-1 卖出一本书,剩余书籍:1
Thread-1 卖出一本书,剩余书籍:0

注意：在使用并发的时候，将域设置为private是非常重要的，否则，synchronized关键字不能防止其他任务直接访问域，这样讲产生冲突问题。

synchronized与static

关键字synchronized可以修饰static静态方法，这个时候是对当前静态方法所属的Class类进行加锁。与修饰普通方法是有差别的。如下：

public class ServiceDemo {
    
    public  static void print1(){
        System.out.println(Thread.currentThread().getName()+" print1 start ");
        System.out.println(Thread.currentThread().getName()+" print1 end ");
    }
    public  static void print2(){
        System.out.println(Thread.currentThread().getName()+" print2 start ");
        System.out.println(Thread.currentThread().getName()+" print2 end ");
    }
    
    public static void main(String[] args) {
        ServiceDemo serviceDemo1 = new ServiceDemo();
        ServiceDemo serviceDemo2 = new ServiceDemo();
        Thread t1 =new Thread(new Thread1(serviceDemo1));
        Thread t2 =new Thread(new Thread2(serviceDemo2));
        t1.start();
        t2.start();
    }
}

class Thread1 implements Runnable{
    private ServiceDemo serviceDemo;
    
    Thread1(ServiceDemo serviceDemo){
        this.serviceDemo = serviceDemo;
    }
    
    @Override
    public void run() {
        serviceDemo.print1();
    }
    
}
class Thread2 implements Runnable{
    private ServiceDemo serviceDemo;
    
    Thread2(ServiceDemo serviceDemo){
        this.serviceDemo = serviceDemo;
    }
    
    @Override
    public void run() {
        serviceDemo.print2();
    }
    
}

输出结果：

Thread-0 print1 start 
Thread-1 print2 start 
Thread-0 print1 end 
Thread-1 print2 end 

使用static和synchronized结合的时候，效果完全不同了,如下：

public class ServiceDemo {
    
    public synchronized static void print1(){
        System.out.println(Thread.currentThread().getName()+" print1 start ");
        System.out.println(Thread.currentThread().getName()+" print1 end ");
    }
    public synchronized static void print2(){
        System.out.println(Thread.currentThread().getName()+" print2 start ");
        System.out.println(Thread.currentThread().getName()+" print2 end ");
    }
    
    public static void main(String[] args) {
        ServiceDemo serviceDemo1 = new ServiceDemo();
        ServiceDemo serviceDemo2 = new ServiceDemo();
        Thread t1 =new Thread(new Thread1(serviceDemo1));
        Thread t2 =new Thread(new Thread2(serviceDemo2));
        t1.start();
        t2.start();
    }
}

class Thread1 implements Runnable{
    private ServiceDemo serviceDemo;
    
    Thread1(ServiceDemo serviceDemo){
        this.serviceDemo = serviceDemo;
    }
    
    @Override
    public void run() {
        serviceDemo.print1();
    }
    
}
class Thread2 implements Runnable{
    private ServiceDemo serviceDemo;
    
    Thread2(ServiceDemo serviceDemo){
        this.serviceDemo = serviceDemo;
    }
    
    @Override
    public void run() {
        serviceDemo.print2();
    }
    
}

输出结果：

Thread-0 print1 start 
Thread-0 print1 end 
Thread-1 print2 start 
Thread-1 print2 end 

从结果看出，两个线程并未共享同一个对象，但是两个不同对象的静态同步方法发生了同步互斥。如果将ServiceDemo类中的一个方法修改为非静态同步方法，上述代码的执行结果则可能不是上面显示的那样了，那是因为如果一个线程执行一个对象的非static synchronized方法，另外一个线程需要执行这个对象所属类的static synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁，而访问非static synchronized方法占用的是对象锁，所以不存在互斥现象。

synchronized修饰代码块

使用关键字synchronized声明方法在某些情况下是有弊端的，非常影响效率。如果多个线程在访问一个synchronized方法，那么同一时刻只有一个线程在执行该方法，而其他线程都必须等待，但是如果该方法没有使用synchronized，则所有线程可以在同一时刻执行它，减少了执行的总时间。在这样的情况下，推荐使用同步语句块来解决，同步方法是对当前对象进行加锁，而synchronized代码块是对某一个对象加锁。synchronized代码块使用起来比synchronized方法要灵活得多。因为也许一个方法中只有一部分代码只需要同步，如果此时对整个方法用synchronized进行同步，会影响程序执行效率。

public class BookSaleRunable3 implements Runnable{
    private int bookNum=20;//书的总数为10
    @Override
    public void run() {
        for(int i=0;i<7;i++){
            synchronized (this) {
                if(bookNum>0){
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+" 卖出一本书,剩余书籍:"+(--bookNum));
                }
            }
        }
        
    }
    
    public static void main(String[] args) {
        BookSaleRunable3 booksr = new BookSaleRunable3();
        //开启3个线程
        Thread t1 = new Thread(booksr);
        Thread t2 = new Thread(booksr);
        Thread t3 = new Thread(booksr);
        t1.start();
        t2.start();
        t3.start();
    }

}

结果输出：

Thread-0 卖出一本书,剩余书籍:19
Thread-0 卖出一本书,剩余书籍:18
Thread-0 卖出一本书,剩余书籍:17
Thread-0 卖出一本书,剩余书籍:16
Thread-0 卖出一本书,剩余书籍:15
Thread-0 卖出一本书,剩余书籍:14
Thread-0 卖出一本书,剩余书籍:13
Thread-2 卖出一本书,剩余书籍:12
Thread-2 卖出一本书,剩余书籍:11
Thread-2 卖出一本书,剩余书籍:10
Thread-2 卖出一本书,剩余书籍:9
Thread-1 卖出一本书,剩余书籍:8
Thread-1 卖出一本书,剩余书籍:7
Thread-1 卖出一本书,剩余书籍:6
Thread-1 卖出一本书,剩余书籍:5
Thread-1 卖出一本书,剩余书籍:4
Thread-1 卖出一本书,剩余书籍:3
Thread-1 卖出一本书,剩余书籍:2
Thread-2 卖出一本书,剩余书籍:1
Thread-2 卖出一本书,剩余书籍:0

总结：

• 当一个线程访问对象的一个synchronized方法的时候，另外的线程仍然可以访问对象的非synchronized方法。
• 当一个线程正在访问一个对象的synchronized方法，那么其他线程不能访问该对象的其他synchronized方法。
• 同一时间只有一个线程可以执行synchronized同步代码块中的代码。
• 如果一个线程执行一个对象的非static synchronized方法，另外一个线程需要执行这个对象所属类的static synchronized方法，此时不会发生互斥现象，因为访问static synchronized方法占用的是类锁，而访问非static synchronized方法占用的是对象锁，所以不存在互斥现象。
• synchronized方法或者synchronized代码块，当出现异常时，JVM会自动释放当前线程占用的锁，因此不会由于异常导致出现死锁现象

2.Lock锁机制

Lock对象必须被显式的创建、锁定和释放，与jvm内建的锁相比，代码缺乏优雅性，但是对于解决某些特殊类型的问题来说，它更加灵活。使用synchronized关键字，需要些的代码量更少。具体的例子如下：

public class BookSaleRunable4 implements Runnable {
    private int bookNum = 10;// 书的总数为10
    private Lock lock = new ReentrantLock();// 重入锁

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            lock.lock();// 显示加锁
            try {
                if (bookNum > 0) {
                    Thread.sleep(300);
                    System.out.println(Thread.currentThread().getName()+" 卖出一本书,剩余书籍:" + (--bookNum));
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally{
                lock.unlock();//主动释放锁，很容易忘记释放锁
            }
        }

    }
    public static void main(String[] args) {
        BookSaleRunable4 booksr = new BookSaleRunable4();
        // 开启3个线程
        Thread t1 = new Thread(booksr);
        Thread t2 = new Thread(booksr);
        Thread t3 = new Thread(booksr);
        t1.start();
        t2.start();
        t3.start();
    }

}

结果输出：

Thread-0 卖出一本书,剩余书籍:9
Thread-0 卖出一本书,剩余书籍:8
Thread-0 卖出一本书,剩余书籍:7
Thread-2 卖出一本书,剩余书籍:6
Thread-2 卖出一本书,剩余书籍:5
Thread-2 卖出一本书,剩余书籍:4
Thread-1 卖出一本书,剩余书籍:3
Thread-1 卖出一本书,剩余书籍:2
Thread-1 卖出一本书,剩余书籍:1