Java多线程编程学习——02线程安全问题

什么是线程安全

如果有多个线程同时运行同一个实现了Runnable接口的类，程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的；反之，则是线程不安全的。

线程安全问题根本原因

多个线程同一时刻操作共享的数据，会导致该共享数据出现与预期的值不符的情况，这样便会引发线程安全问题。

问题解决-线程同步

要解决线程安全问题，只要在某个线程修改共享资源的时候，其他线程不能修改该资源，等待该线程修改完毕同步之后，其他线程才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行共享资源操作,Java引入了7种线程同步机制。

1. 同步代码块（synchronized）
2. 同步方法（synchronized）
3. 同步锁（ReenreantLock）
4. 特殊域变量（volatile）
5. 局部变量（ThreadLocal）
6. 阻塞队列（LinkedBlockingQueue）
7. 原子变量（Atomic*）

同步代码块（synchronized）

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

同步锁: 对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象可以是任意类型。
2. 多个线程要使用同一把锁。

注意：在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

同步代码块代码

public class MyThread05 implements Runnable {

    private int tickNum = 200;

    Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (tickNum > 0) {
                    //1.模拟出票时间
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //2.打印进程号和票号，票数减1
                    String name = Thread.currentThread().getName();
                    System.out.println("线程" + name + "售票：" + tickNum--);
                }
            }
        }
    }

    public static void main(String[] args) {
        MyThread05 myThread=new MyThread05();
        Thread thread01 = new Thread(myThread,"窗口1");
        Thread thread02 = new Thread(myThread,"窗口2");
        Thread thread03 = new Thread(myThread,"窗口3");
        thread01.start();
        thread02.start();
        thread03.start();
    }
}

同步方法（synchronized）

同步方法：

使用synchronized修饰的方法,就叫做同步方法,保证当前线程执行该方法的时候,其他线程无法访问该方法，因为该方法已经被锁定，直到当前线程运行完毕释放资源。

同步锁是谁?

1. 对于非static方法,同步锁就是this。
2. 对于static方法,同步锁是当前方法所在类的字节码对象(类名.class)。

同步方法代码

public class MyThread06 implements Runnable {

    private int tickNum = 100;

    Object obj = new Object();

    @Override
    public void run() {
        //使用while(true)的作用：
        //
        //run方法中的代码就是线程要运行的代码，运行完毕以后，就不会再次运行，
        // 其方法本身并不是无限循环的。而while(true)是为了让run方法中的代码不断重复的运行，
        // 也就是让线程不停的运行，便于查看效果。如果去掉，run运行结束，线程也就结束了
        while (true) {
            getTick();
        }
    }

    public synchronized void getTick() {
        while (true) {
            if (tickNum > 0) {
                //1.模拟出票时间
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //2.打印进程号和票号，票数减1
                String name = Thread.currentThread().getName();
                System.out.println("线程" + name + "售票：" + tickNum--);
            }
        }
    }

    public static void main(String[] args) {
        MyThread06 myThread = new MyThread06();
        Thread thread01 = new Thread(myThread, "窗口1");
        Thread thread02 = new Thread(myThread, "窗口2");
        Thread thread03 = new Thread(myThread, "窗口3");
        thread01.start();
        thread02.start();
        thread03.start();
    }
}

同步锁（ReenreantLock）

同步锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

同步锁方法

1. public void lock() :加同步锁。
2. public void unlock() :释放同步锁。

同步锁代码

public class MyThread07 implements Runnable {
    private int tickNum = 100;

    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (tickNum > 0) {
                    //1.模拟出票时间
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //2.打印进程号和票号，票数减1
                    String name = Thread.currentThread().getName();
                    System.out.println("线程" + name + "售票：" + tickNum--);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        MyThread07 myThread = new MyThread07();
        Thread thread01 = new Thread(myThread, "窗口1");
        Thread thread02 = new Thread(myThread, "窗口2");
        Thread thread03 = new Thread(myThread, "窗口3");
        thread01.start();
        thread02.start();
        thread03.start();
    }
}

Synchronized和Lock区别

1. synchronized是java内置关键字；在jvm层面，Lock是个java类。
2. synchronized无法判断是否获取锁的状态；Lock可以判断是否获取到锁。
3. synchronized会自动释放锁，当前线程执行完同步代码会释放锁，若线程执行过程中发生异常会释放锁)；Lock需在finally中手动释放锁（unlock()方法释放锁），否则容易造成线程死锁。
4. synchronized关键字加锁，如果当前线程获得锁，则其他线程等待。如果当前线程阻塞，其他线程则会一直等待下去；而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了。
5. synchronized的锁可重入、不可中断、非公平；而Lock锁可重入、可判断、可公平（两者皆可）
6. Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。