多线程、线程安全

1、线程安全：

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

线程安全问题实例：

电影院要卖票，我们模拟电影院的卖票过程。本次电影的座位共100个(本场电影只能卖100张票)。

模拟电影院的售票窗口，实现多个窗口同时卖这100张票

模拟实现买票功能：

public class Ticket implements Runnable {
    //共100票
    int ticket = 100;
//重写run()方法
    public void run() {
        //模拟卖票
        while(true){
            if (ticket > 0) {
                //模拟选坐的操作
                try {
                                       //线程休眠1毫秒
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
//当检测剩余票数大于0时，售票，余票减一，显示卖出的是第几张票                
System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
            }
        }
    }

创建测试类，模拟多线程：

public class ThreadDemo {
    public static void main(String[] args) {
        //创建票对象
        Ticket ticket = new Ticket();
        
        //创建3个窗口
        Thread t1  = new Thread(ticket, "窗口1");
        Thread t2  = new Thread(ticket, "窗口2");
        Thread t3  = new Thread(ticket, "窗口3");
        //运行三个线程
        t1.start();
        t2.start();
        t3.start();
    }
}

结果显示：

程序问题：1、出现重复票 2、出现错误票0和-1

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程运行有六种状态：

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。 

线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。 

3.阻塞(BLOCKED)：表示线程阻塞于锁，或者CPU资源被抢走，当解锁或CPU空闲时，自动转为运行状态。

4.等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。通过wait()方法进入等待状态，可通过notify()方法唤醒，自己不能自醒。

5.超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。通过sleep()方法，设置时间进入休眠状态，到时间后可自醒。

6 终止(TERMINATED)：表示该线程已经执行完毕，run（）方法结束 

线程状态图：

2、线程同步---同步代码块

 用线程同步线程安全处理Synchronized解决线程安全问题。

同步代码块: 在代码块声明上 加上synchronized

synchronized (锁对象) {
    可能会产生线程安全问题的代码
}

同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

使用同步代码块，对电影院卖票案例中Ticket类进行如下代码修改：

public class Ticket implements Runnable {
    //共100票
    int ticket = 100;
    //自定义锁对象
    Object lock = new Object();
    public void run() {
        //模拟卖票
        while(true){
            //同步代码块
            synchronized (lock){
                if (ticket > 0) {
                    //模拟电影选坐的操作
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
                }
            }
        }
    }
}

3、线程同步---同步方法

同步方法：在方法声明上加上synchronized

public synchronized void method(){
       可能会产生线程安全问题的代码
}

同步方法中的锁对象是 this

使用同步方法，对电影院卖票案例中Ticket类进行如下代码修改：

public class Ticket implements Runnable {
    //共100票
    int ticket = 100;
    //定义锁对象
    Object lock = new Object();
    @Override
    public void run() {
        //模拟卖票
        while(true){
            //同步方法
            method();
        }
    }

//同步方法,锁对象this
    public synchronized void method(){
        if (ticket > 0) {
            //模拟选坐的操作
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
        }
    }
}

4、静态同步方法: 在方法声明上加上static synchronized

public static synchronized void method(){
可能会产生线程安全问题的代码
}

静态同步方法中的锁对象是 类名.class

5、死锁

同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。

这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。

synchronzied(A锁){
    synchronized(B锁){        
    }
}

死锁情况的代码演示：

定义锁对象类：

public class MyLock {
    public static final Object lockA = new Object();
    public static final Object lockB = new Object();
}

线程任务类：

public class ThreadTask implements Runnable {
    int x = new Random().nextInt(1);//0,1
    //指定线程要执行的任务代码
    @Override
    public void run() {
        while(true){
            if (x%2 ==0) {
                //情况一
                synchronized (MyLock.lockA) {
                    System.out.println("if-LockA");
                    synchronized (MyLock.lockB) {
                        System.out.println("if-LockB");
                        System.out.println("if大口吃肉");
                    }
                }
            } else {
                //情况二
                synchronized (MyLock.lockB) {
                    System.out.println("else-LockB");
                    synchronized (MyLock.lockA) {
                        System.out.println("else-LockA");
                        System.out.println("else大口吃肉");
                    }
                }
            }
            x++;
        }
    }
}

测试类：

public class ThreadDemo {
    public static void main(String[] args) {
        //创建线程任务类对象
        ThreadTask task = new ThreadTask();
        //创建两个线程
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        //启动线程
        t1.start();
        t2.start();
    }
}

6、Lock接口

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

常用方法：

Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。

我们使用Lock接口，以及其中的lock()方法和unlock()方法替代同步，对电影院卖票案例中Ticket类进行如下代码修改：

public class Ticket implements Runnable {
    //共100票
    int ticket = 100;    
    //创建Lock锁对象，ReentrantLock是Lock的子类
    Lock ck = new ReentrantLock();    
    public void run() {
        //模拟卖票
        while(true){
            //synchronized (lock){
            ck.lock();
                if (ticket > 0) {
                    //模拟选坐的操作
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);
                }
            ck.unlock();
            //}
        }
    }
}