目录

一、多线程安全

线程安全的概述

二、死锁

死锁的概述：

三、线程状态

线程状态概述

四、多线程等待唤醒机制

多线程等待唤醒机制的概述

---

一、多线程安全

• 线程安全的概述

解析：

1.多线程安全问题的出现：就是多个线程操作同一共享数据时才会出现的问题，

举个例子：比如有一个景区系统卖100张票，一共有4个窗口同时卖票，若不时时共享数据就会出现卖重复票或者跳票的现象出现，而这些票又是真的，而卖出重复票与跳票又不合生活实际，因此我们必须解决这种问题出现。

2.解决这种问题的方法比较合理的就是：将数据同步共享就能完美解决问题咯。

3.在java中有3种同步数据方式分别如下：

3.1同步代码块：

加同步格式：

synchronized( 需要一个任意的对象（锁）)

    {

代码块中放操作共享数据的代码。

}

注意：其中的锁对象可以为任意，且不唯一即可。

3.2同步方法

public synchronized void 方法名(参数列表){

        方法体中放操作共享数据的代码。

}

注意：1.如果一个方法内部，所有代码都需要被同步，那么就用同步方法； 2.同步方法的锁对象由默认给予，且为this对象。

3.3静态同步方法

public synchronized void 方法名(参数列表){

        方法体中放操作共享数据的代码。

}

注意：静态同步方法的锁对象为class对象。

3.4锁升级：在JDK5以后java中提供了一个Lock接口，在这个接口中定义了锁的释放和获取的方法，后期程序中需要使用同步，这时可以使用Lock接口的实现类显示的完成锁的获取和释放的动作；这种方式供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有。

使用步骤如下：

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock()：加同步锁。

public void unlock()：释放同步锁。

使用注意：在使用Lock锁对象时，需要手动的书写代码用来：获取锁、释放锁，上述方式由于Lock是接口，不能创建对象，只能使用我们可以使用它的子类ReentrantLock来创建对象并使用Lock接口中的函数。

买票代码使用演示：

 任务类代码：其中四种使用方式都写入，自己切换演示即可，我们这里演示第一种使用方式

package com.feisi.week7.day2;
 
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class SellTicketTask implements Runnable {
    // 定义100张票
     int tickets = 100;
    Lock lock = new ReentrantLock();
 
    @Override
    public void run() {
        // 使用循环模拟一直买票
        while (true) {
            // 加锁，当一个线程进来之后就上锁，防止其他线程进来捣乱
            // 使用同步代码块
            synchronized ("") {
                // 判断是否还有余票
                if (tickets > 0) {
                    try {
                        // 为了解决线程拥挤，方便线程的调度
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " " + tickets);
                    // 余票减一
                    tickets--;
                }
            }
        }
        //sh();
 
    }
 
    // 非静态唯一对象为this  同步代码块为自己给定的对象且唯一
    public synchronized void sy() {
        // 使用循环模拟一直买票
        while (true) {
            // 加锁，当一个线程进来之后就上锁，防止其他线程进来捣乱
            // 使用同步代码块
                // 判断是否还有余票
                if (tickets > 0) {
                    try {
                        // 为了解决线程拥挤，方便线程的调度
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " " + tickets);
                    // 余票减一
                    tickets--;
            }
        }
    }
 
    /*//  静态为class对象也就是本身的字节码对象
    public static synchronized void syj() {
        // 使用循环模拟一直买票
        while (true) {
                // 判断是否还有余票
                if (tickets > 0) {
                    try {
                        // 为了解决线程拥挤，方便线程的调度
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " " + tickets);
                    // 余票减一
                    tickets--;
                }
        }
    }*/
 
    // 使用lock接口 上锁 直观一些
    public void sh() {
        // 使用循环模拟一直买票
        while (true) {
            // 加锁，当一个线程进来之后就上锁，防止其他线程进来捣乱
            // 使用同步代码锁 上锁
            lock.lock();
            // 判断是否还有余票
            if (tickets > 0) {
                try {
                    // 为了解决线程拥挤，方便线程的调度
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " " + tickets);
                // 余票减一
                tickets--;
            }
            // 解锁
            lock.unlock();
        }
    }
 
}

测试类：

package com.feisi.week7.day2;
 
public class Test {
    public static void main(String[] args) {
        // 创建线程任务类对象
        SellTicketTask sellTicketTask = new SellTicketTask();
        // 创建线程类对象，开启线程
        Thread thread = new Thread(sellTicketTask, "线程1");
        Thread thread1 = new Thread(sellTicketTask, "线程2");
        Thread thread2 = new Thread(sellTicketTask, "线程3");
        Thread thread3 = new Thread(sellTicketTask, "线程4");
 
        // 开始线程
        thread.start();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

 运行结果：这里展示一部分结果，可见上述多线程安全现象依然解决。

 

二、死锁

• 死锁的概述：

解析：

1.死锁是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待的现象。

2.死锁的现象的出现必须集齐以下几点：

2.1有多把锁

2.2有多个线程

2.3有同步代码块嵌套

3.简单的来说就是，举个例子：两个人为了打开一个有两把锁的箱子拿到里面的东西，东西只有一份，缺一把都打不开拿，然而A拿到了第一把钥匙，B拿到了第二把钥匙，两个人都想拿到那一份东西，所以你的钥匙不给我，我的也不给你，就会造成所谓的死锁互斥现象谁也拿不到拿一份东西，在程序中则体现为导致程序卡主，无法继续运行。

特别注意：1.解决死锁现象只能修改源代码才能解决，此外别无它法。2. 可以使用一个同步代码块解决的问题，不要使用嵌套的同步代码块，如果要使用嵌套的同步代码块，就要保证同步代码块的上的对象锁使用同一个对象锁（唯一的对象锁）

现象出现演示：

package com.feisi.week7.day2;
 
public class DeadLock implements Runnable{
    // 定义锁
    Object lock_a = new Object();
    Object lock_b = new Object();
 
    boolean flag = true;
    @Override
    public void run() {
        // 循环
        while (true) {
            if (flag){
                // 先做a 再做b
                synchronized (lock_a){
                    System.out.println(Thread.currentThread().getName()+"在做A事情");
                    synchronized (lock_b){
                        System.out.println(Thread.currentThread().getName()+"在做B事情");
                    }
                }
            }else {
                // 先做b 再做a
                synchronized (lock_b){
                    System.out.println(Thread.currentThread().getName()+"在做B事情");
                    synchronized (lock_a){
                        System.out.println(Thread.currentThread().getName()+"在做A事情");
                    }
                }
            }
        }
 
    }
}

测试类：

package com.feisi.week7.day2;
 
public class Test {
    public static void main(String[] args) {
       
        // 创建任务类对象 死锁现象
        DeadLock deadLock = new DeadLock();
        Thread thread = new Thread(deadLock,"线程1");
        Thread thread1 = new Thread(deadLock,"线程2");
 
        // 启动线程
        thread.start();
        // 要让主线程休眠一会
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        deadLock.flag = false;
        thread1.start();
    }
}

运行结果：由下图可见就造成了死锁现象。 

三、线程状态

• 线程状态概述

解析：

1.线程生命周期：就是线程从生到死。

2.当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在API中java.lang.Thread.State这个枚举中给出了六种线程状态：如下表所示：

注意：关于CPU执行线程有两个概念需要了解下：

CPU的执行资格：在CPU执行的队列中等待。还没有被CPU执行。

CPU的执行权：当前持有CPU资源，正在被执行。

结合下图理解：

特别注意：其中我们需要重点理解从可运行run到非运行状态之间切换即可。 

四、多线程等待唤醒机制

• 多线程等待唤醒机制的概述

解析：

1.在使用多线程的时候可规划为两种情况：一是所有的线程做同样的任务，二是多线程中做着不同的任务。

2.在做不同任务时，在程序中，最常见的一种模型，就是生产者和消费者模型。生产者线程和消费者线程之间需要进行通信，我们可以使用等待唤醒机制来实现生产者线程和消费者线程之间的通信。

1.唤醒机制所涉及的方法

Object类的方法 ：

wait()        :让当前线程进入等待状态
notify()    :唤醒一个正在等待的线程，唤醒是随机的
void notifyAll() 唤醒在此对象监视器上等待的所有线程。 

注意事项： 1.必须要使用锁对象来调用的。2.由于锁对象可以是任意类型的对象，这些方法放在Object类中最好，因为Object类是所有类超类。3.两个方法必须要在同步里面调用，因为在同步里面才有锁对象。

特别注意：1.如果一个线程执行了wait()方法，那么当前线程进入等待状态，并且会释放锁对象，下次即使被唤醒必须获取到锁对象才可以执行。 2.且两个线程必须使用同锁对象。3.且在调用wait()，notify()和notifyAll()的线程在调用这些方法前必须"拥有"对象的锁，否则将会报错如下异常，因此为了解决如下异常将调用上述3种方法时，应使用同步代码块让其线程获取当前锁再进行操作。

 

案例演示：包子铺卖包子案例

包子类：

package com.feisi.week7.day2;
 
public class Baozi {
    String pi;
    String xing;
    boolean flag = true;
 
    public Baozi(String pi, String xing, boolean flag) {
        this.pi = pi;
        this.xing = xing;
        this.flag = flag;
    }
}

生产者类：

package com.feisi.week7.day2;
 
public class Zuo implements Runnable{
    Baozi baozi;
 
    public Zuo(Baozi baozi) {
        this.baozi = baozi;
    }
 
    @Override
    public void run() {
        if (baozi.flag){
            // 给予当前线程锁对象
            synchronized ("锁"){
                try {
                    "锁".wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        // 给予当前线程锁对象
        synchronized ("锁"){
            baozi.flag = true;
            System.out.println("我生产了"+baozi.pi+"皮"+baozi.xing+"馅的包子");
            // 唤醒消费者 吃包子
            "锁".notify();
        }
 
    }
}

消费者类：

package com.feisi.week7.day2;
 
public class Chi implements Runnable{
    Baozi baozi;
 
    public Chi(Baozi baozi) {
        this.baozi = baozi;
    }
 
    @Override
    public void run() {
        // 若没有包子则消费沉睡
        if (baozi.flag==false){
            // 给予当前线程锁对象
            synchronized ("锁"){
                try {
                    "锁".wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        // 给予当前线程锁对象
        synchronized ("锁"){
            // 吃完包子把生产者叫醒
            baozi.flag = false;
            System.out.println("我吃了了"+baozi.pi+"皮"+baozi.xing+"馅的包子");
            "锁".notify();
        }
 
    }
}

测试类：

package com.feisi.week7.day2;
 
public class Test2 {
    public static void main(String[] args) {
        // 创建任务线程对象
        Baozi baozi = new Baozi("白面","牛肉",true);
        Chi chi = new Chi(baozi);
        Zuo zuo = new Zuo(baozi);
 
        // 创建线程
        Thread thread = new Thread(chi);
        Thread thread1 = new Thread(zuo);
 
        // 开启线程
        thread.start();
        thread1.start();
 
    }
}

运行结果：由于我没有加循环就只有两个输出结果，想多输出的小伙伴再代码中加上循环即可，且解决了上述异常问题。