Java-线程安全

博文仅为学习记录，仅供参考

---

Java-线程安全问题

产生原因：多个线程访问共享数据

范例：

MyThread类：

public class MyThread implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
            ticket--;
        }
    }
}

Main类：

package com.day20.threadSafe;

public class Main {
    public static void main(String[] args) {
        //创建MyThread类对象，命名为mt
        MyThread mt=new MyThread();

        //创建3个Thread类对象，将mt作为参数传入构造方法，并将三个Thread对象的name分别设为“窗口1”、“窗口2”、“窗口3”。
        Thread t0=new Thread(mt,"窗口1");
        Thread t1=new Thread(mt,"窗口2");
        Thread t2=new Thread(mt,"窗口3");

        t0.start();
        t1.start();
        t2.start();
    }
}

编译运行，控制台输出：

窗口1正在卖第100张票
窗口1正在卖第99张票
窗口1正在卖第98张票
窗口1正在卖第97张票
窗口1正在卖第96张票
窗口2正在卖第100张票
窗口3正在卖第100张票
窗口3正在卖第93张票
……

上面省略了后面输出的内容，先看前面的输出，注意到这三条输出：“窗口1正在卖第100张票”、“窗口2正在卖第100张票”、“窗口3正在卖第100张票”，按理说，如果窗口1正在卖100张票，那么窗口2和3就不能再卖第100张票，但是现在都在卖第100张票。这里的票属于资源，3个线程访问同样的资源，且每个线程访问资源后资源状态都要发生改变（这里是ticket减1），但是很明显这里3个线程访问到的资源是同一个状态，这就出现了安全问题。

原因是什么呢？从这里来说，假如出现这种状况：每个线程执行println()方法之后还没来得及执行ticket–语句就被其他线程抢占了CPU执行权，导致下个执行的线程访问到的ticket状态和上一个一样，就出现了线程安全问题。

如何解决线程安全问题？多个线程访问共享数据，可以让一个线程在访问共享数据的时候，无论是否失去CPU执行权，让其他线程必须等待，等到这个线程访问共享数据操作完成，其他线程才能访问共享数据。

为了解决线程安全问题，Java引入了线程同步机制。

有3种方式可以完成线程同步：

1. 同步代码块
2. 同步方法
3. Lock锁机制

***同步代码块：***

synchronized关键字可以作用于方法的某个区块，表示只对这个区块的资源实行互斥访问。

synchronized(锁对象){
	
}

要注意的是：

1. 同步代码块中的锁对象，可以使用任意的对象
2. 锁对象的作用：把同步代码块锁住，只让一个线程执行同步代码块。
3. 必须保证多个线程使用的锁对象是同一个

同步代码块保证线程同步的原理是：

当一个线程执行run()方法时，遇到synchronized代码块，此时线程会检查synchronized代码块是否有锁对象，如果发现有，就获取锁对象，执行synchronized里面的代码块，执行完毕，就会释放锁对象，如果在释放锁对象之前被其他线程抢占了CPU执行权，就会进入阻塞状态，锁对象不会被释放，那么下一个线程执行run方法时，获取不到synchronized代码块的锁对象，也会进入阻塞状态。简而言之，一个线程如果想执行synchronized代码块，就必须先获取到锁对象，如果获取不到，说明锁对象被其他线程占用，就不会执行synchronized代码块，从而保证了线程间的同步。

范例：

MyThread01类：

public class MyThread01 implements Runnable {
    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖出第" + ticket + "张票");
                    ticket--;
                }
            }
        }
    }
}

Main类：

public class Main {
    public static void main(String[] args) {
        MyThread01 mt=new MyThread01();

        Thread t0=new Thread(mt,"窗口1");
        Thread t1=new Thread(mt,"窗口2");
        Thread t2=new Thread(mt,"窗口3");

        t0.start();
        t1.start();
        t2.start();

    }
}

编译运行，控制台输出：

窗口1正在卖出第100张票
窗口3正在卖出第99张票
窗口3正在卖出第98张票
窗口3正在卖出第97张票
窗口3正在卖出第96张票
窗口3正在卖出第95张票
窗口3正在卖出第94张票
……

“……”为后面输出内容的省略，使用了同步代码块之后就可以使线程同步。

***同步方法：***

使用synchronized修饰的方法，就叫做同步方法，保证一个线程执行该方法时，其他线程只能在方法外等着。

同步锁对象是哪个？

​ 1.对于非static方法，同步锁是this

​ 2.对于static方法，同步锁是当前方法所在类的字节码对象（类名.class）

格式：

修饰符 synchronized 返回值 方法名(参数列表){
	可能产生线程安全问题的代码块
}

范例：

MyThread02类：

public class MyThread02 implements Runnable{
    private int ticket=100;

    @Override
    public void run() {
        while(true){
            method();
        }
    }
    public synchronized void method(){
        if(ticket>0){
            System.out.println(Thread.currentThread().getName() + "正在卖出第" + ticket + "张票");
            ticket--;
        }
    }
}

Main类：

public class Main {
    public static void main(String[] args) {
        MyThread02 mt=new MyThread02();

        Thread t0=new Thread(mt,"窗口1");
        Thread t1=new Thread(mt,"窗口2");
        Thread t2=new Thread(mt,"窗口3");

        t0.start();
        t1.start();
        t2.start();

    }
}

编译运行的结果就不给出了，同步方法也可以实现线程间的同步。

Lock：

public interface Lock：Lock实现提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化，可能具有完全不同的属性，并且可以支持多个关联的Condition对象。

使用方式：

• void lock()：获得锁
• void unlock()：释放锁

Lock中的lock()和unlock()用来获得锁和释放锁，但Lock是一个接口，要使用这两个方法，就有用到Lock的实现类，有一个Lock的实现类：ReentrantLock类。用Lock机制实现线程同步的具体步骤是：

1.在成员位置创建一个ReentrantLock类的对象

2.在可能出现线程安全问题的代码前调用lock()

3.在可能出现线程安全问题的代码后调用unlock()

范例：

MyThread03类：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread03 implements Runnable {
    private int ticket = 100;
    //创建ReentrantLock()对象
    Lock l = new ReentrantLock();

    @Override
    public void run() {

        while (true) {
            l.lock();
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "正在卖出第" + ticket + "张票");
                ticket--;
            }
            l.unlock();
        }
    }
}

测试类Main类：

public class Main {
    public static void main(String[] args) {
        MyThread03 mt=new MyThread03();

        Thread t0=new Thread(mt,"窗口1");
        Thread t1=new Thread(mt,"窗口2");
        Thread t2=new Thread(mt,"窗口3");

        t0.start();
        t1.start();
        t2.start();

    }
}

编译运行的输出不给出，Lock机制能够保证线程同步，在JDK官方文档中，一种更为建议的写法是，用try-catch-finally语句包含可能出现线程安全问题的代码块，然后在finally语句中调用unlock()方法，这样写的好处是，即使代码块抛出了异常，最后也能保证释放锁。

例如：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread03 implements Runnable {
    private int ticket = 100;
    //创建ReentrantLock()对象
    Lock l = new ReentrantLock();

    @Override
    public void run() {

        while (true) {
            l.lock();
            try{
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖出第" + ticket + "张票");
                    ticket--;
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                l.unlock();
            }
        }
    }
}

时间：2020年10月18日23:46:35

---

博文仅为学习记录，仅供参考