JavaSE进阶十线程二

死锁

什么是死锁

死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，
若无外力作用，它们都将无法推进下去。
此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的线程称为死锁线程。

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个线程使用
请求与保持条件：一个线程因请求资源而阻塞时，对已获得的资源保持不放
不剥夺条件：线程已获得的资源，在未使用完之前，不能强行剥夺
循环等待条件：若干进程之间形成一种头尾相连的循环等待资源关系

代码示例

写一个死锁代码，只有会写，才会在以后的开发中注意这个事。

public class DeadLockTest01 {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();

        MyThread1 thread1 = new MyThread1(o1,o2);
        MyThread2 thread2 = new MyThread2(o1,o2);

        thread1.start();
        thread2.start();
    }
}

class MyThread1 extends Thread{
    Object obj1;
    Object obj2;
    public void run(){
        synchronized (obj1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj2){

            }
        }
    }

    public MyThread1(Object obj1, Object obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
}

class MyThread2 extends Thread{
    Object obj1;
    Object obj2;
    public void run(){
        synchronized (obj2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj1){

            }
        }
    }

    public MyThread2(Object obj1, Object obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
}

守护线程

java语言中线程分为两大类
- 用户线程：
  - 主线程main方法就是一个用户线程
- 守护线程：
  - 最具有代表性的：垃圾回收线程（守护线程）。
守护线程的特点：
- 一般守护线程是一个死循环，所有的用户线程结束了，守护线程才会自动结束。

守护线程用在什么地方？

每天00:00的时候系统数据自动备份。
这个需要用到定时器，并且我们可以将定时器设置为守护线程。一直在那守着，
每到00:00的时候就备份一次；所有的用户线程结束了，守护线程自动退出，没
必要继续数据备份了。

代码示例

public class DaemonThreadTest01 {
    public static void main(String[] args) {
        BakDataThread bakDataThread = new BakDataThread();
        bakDataThread.setName("守护线程");
        // 启动线程之前，将该线程设置为守护线程
        bakDataThread.setDaemon(true);
        bakDataThread.start();

        for (int i = 0;i < 10; i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

class BakDataThread extends Thread{
    public  void run(){
        int i= 0;
        //  即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止。
        while (true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + i++);
        }
    }
}

定时器

定时器的作用：
- 间隔特定的时间，执行特定的程序。
- 在实际开发中，没隔多久执行一段特定的程序，这是常见的。
java中实现定时器有多种方式：
- 1，可以使用sleep方法，睡眠，设置睡眠时间；每到这个时间点醒来，执行任务；
  这种方式是最原始的定时器。（比较low）
- 2，使用java类库中写好的定时器，java.util.Timer，可以直接拿来用。这种方式
  在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
- 3，例如：现在常用的spring框架中提供的springTask框架，这个框架只有进行简单
  的配置，就可以完成定时器任务。

代码示例

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TimerThreadTest01 {
    public static void main(String[] args) {
        // 创建定时器对象
        Timer timer = new Timer();
        // Timer timer = new Timer(true); //守护线程写法

        //指定定时任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = null;
        try {
            firstTime = sdf.parse("2021-06-03 17:53:15");
        } catch (ParseException e) {
            e.printStackTrace();
        }
        // schedule(定时任务,开始执行时间,间隔多久执行一次);
        timer.schedule(new LogTaskTimer(),firstTime,1000 * 10);
    }
}

// 编写一个定时任务
class LogTaskTimer extends TimerTask{

    @Override
    public void run() {
        // 这里编写需要执行的任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = sdf.format(new Date());
        System.out.println(time + "定时任务开始执行了");
    }
}

实现线程的第三种方式：

实现Callable接口。（JDK8新特性）
- 在java.util.concurrent包下，属于java并发包，老版JDK没有。
- 优点：这种方式实现的线程可以获取线程执行的返回值。
- 之前讲解的那两种方式是无法获取线程返回值的，因为run方法返回的是void。
- 缺点：效率比较低，在获取某个线程执行结果的时候，当前线程受阻塞，效率较低。

代码示例

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadTest09 {
    public static void main(String[] args) {
        // 第一步：创建一个"未来任务类"对象
        MyThreadCallable callable = new MyThreadCallable();
        FutureTask task = new FutureTask(callable);

        //创建线程对象
        Thread t = new Thread(task);
        t.setName("task");
        t.start();// 启动线程

        // 在main方法中 获取t线程的返回结果
        // task.get()方法的执行会阻塞当前线程
        try {
            Object obj = task.get();
            System.out.println(Thread.currentThread().getName() + "线程返回值是" + obj);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        // task.get()方法的执行会阻塞main方法下面程序的执行
        // main方法下面的程序想要执行，必须等待get()方法执行结束，
        // get()方法可能需要很久，因为get()方法是为了拿另一个线程的执行结果。
        System.out.println("hello world");

    }
}

class MyThreadCallable implements Callable{

    @Override
    public Object call() throws Exception {
        // call()方法就相当于run方法。只不过这个有返回值
        // 线程执行一个任务，执行之后可能会有一个执行结果
        // 模拟执行
        System.out.println("call method begin");
        Thread.sleep(1000 * 5);
        System.out.println("call method end");
        int a = 100;
        int b = 200;
        return a + b ;
    }
}

关于Object类中的wait和notify方法（生产者和消费者模式！）

什么是"生产者和消费者模式"？
- 生产线程负责生产，消费线程负责消费。
- 生产线程和消费线程要达到均衡。
- 这是一种特殊的业务需要，在这种特殊的情况下需要使用wait方法和notify方法。
wait方法和notify方法不是线程对象的方法，是java对象都有的方法，是Object类自带的。
wait方法和notify方法是建立在synchronized线程同步的基础之上，因为多线程要同时操作一个厂库，有线程安全问题。
wait方法的作用：
```
 Object o = new Object();
o.wait();
```
- 表示让正在o对象上活动的线程进入等待状态，并且释放掉线程之前占用o对象的锁；直到被唤醒为止。
notify方法的作用：
- notify方法的调用可以让正在o对象上等待的线程唤醒，只是通知，不会释放o对象上之前占有的锁。
- notifyAll方法：唤醒o对象上处于等待的所有线程。

代码示例

模拟需求：
仓库采用list集合，list集合中假设只能存储一个元素；一个元素表示仓库满了，
如果list集合中元素个数是0，就表示仓库空了；保证list集合永远都是最多存储一个元素。
做到：生产一个消费一个。

import java.util.ArrayList;
import java.util.List;

public class ThreadTest10 {
    public static void main(String[] args) {
        //创建一个共享对象
        List list = new ArrayList();

        // 创建两个线程对象
        // 生产者线程
        Thread t1 = new Thread(new Producer(list));
        // 消费者线程
        Thread t2 = new Thread(new Consumer(list));

        t1.setName("生产者线程");
        t2.setName("消费者线程");

        // 启动线程
        t1.start();
        t2.start();
    }
}

// 生产线程
class Producer implements Runnable{
    // 仓库
    private List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() { //一直生产
        while (true){
            // 给仓库对象list加锁
            synchronized (list){
                if (list.size() > 0){// 仓库已满
                    try {
                        list.wait(); // 当前线程进入等待状态，并释放Producer之前占有list集合的锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 程序执行到这里说明仓库是空的，可以生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "-->" + obj);
                // 唤醒消费者进行消费
                list.notify();
                // list.notifyAll();
            }
        }
    }
}
// 消费线程
class Consumer implements Runnable{
    // 仓库
    private List list;
    public Consumer(List list) {
         this.list = list;
    }
    @Override
    public void run() {//一直消费
        while (true){
            synchronized (list) {
                if (list.size() == 0) {// 仓库空了
                    try {
                        list.wait(); // 消费者线程等待，释放掉list集合的锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 程序执行到此处说明仓库中有数据，进行消费。
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "-->" + obj);

                //唤醒生产者生产
                list.notify();
                // list.notifyAll();
            }
        }
    }
}

上篇：JavaSE进阶十线程一
下篇：JavaSE进阶十一反射机制一

最后编辑于：2021.06.21 21:04:31

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,362评论 5赞 477
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,330评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,247评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,560评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,580评论 5赞 365
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,569评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,929评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,587评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,840评论 1赞 297
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,596评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,678评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,366评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,945评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,929评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,165评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 43,271评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,403评论 2赞 342

JavaSE进阶十 线程二

死锁

代码示例

守护线程

代码示例

定时器

代码示例

实现线程的第三种方式：

代码示例

关于Object类中的wait和notify方法（生产者和消费者模式！）

代码示例

推荐阅读更多精彩内容

JavaSE进阶十线程二