多线程并发基础

1、多线程概述

一、多线程

1、什么是进程?什么是线程?

进程是一个应用程序(1个进程是一个软件)。

线程是一个进程中的执行场景/执行单元。

一个进程可以启动多个线程。

对于java程序来说，当在DOS命令窗口中输入:
java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。
JVM再启动一个主线程调用main方法.同时再启动一个垃圾回收线程负责看护，回收垃圾。
最起码，现在的java程序中至少有两个线程并发，
一个是垃圾回收线程，一个是执行main方法的主线程.

2、进程和线程是什么关系?举例

阿里巴巴：进程
马云：阿里巴巴的一个线程
童文红：阿里巴巴的一个线程

京东：进程
强东：京东的一个线程
妹妹：京东的一个线程

进程可以看做是现实生活中的公司。

线程可以看做是公司当中的某个员工。

注意：进程A和进程B的内存独立不共享。（阿里和京东的资源不会共享）
魔兽游戏是一个进程
酷狗音乐是一个进程
这两个进程是独立的，不共享资源。

线程A和线程B呢?

• 在java语言中:
  线程A和线程B，堆内存和方法区内存共享。
  但是栈内存独立，一个线程一个栈。

假设启动10个线程，会有10个栈空间，每个栈和每个栈之间，互不干扰，各自执行各自的，这就是多线程并发。

火车站，可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票，你可以在窗口2购票，你不需要等我，我也不需要等你,所以多线程并发可以提高效率。

java中之所以有多线程机制，目的就是为了提高程序的处理效率。

3、使用了多线程机制之后，main方法结束，有可能程序也不会结束。

因为main方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。

二、多线程并发的理解

分析一个问题:对于单核的CPU来说，真的可以做到真正的多线程并发吗?

对于多核的CPU电脑来说，真正的多线程并发是没问题的。
4核CPU表示同一一个时间点上，可以真正的有4个进程并发执行。

什么是真正的多线程并发?
t1线程执行t1的。
t2线程执行t2的。
t1不会影响t2，t2也不会影响t1.这叫做真正的多线程并发。

单核的CPU表示只有一个大脑:
不能够做到真正的多线程并发，但是可以做到给人一种**”多线程并发”的感觉**。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是:多个事情同时在做!!!
线程A:播放音乐
线程B:运行魔兽游戏
线程A和线程B频繁切换执行，人类会感觉音乐一直在播放，游戏一直在运行,
给我们的感觉是同时并发的。

电影院采用胶卷播放电影，一个胶卷一个胶卷播放速度达到一定程度之后，人类的眼睛产生了错觉，感觉是动画的。这说明人类的反应速度很慢，就像一根钢针扎到手上，到最终感觉到疼，这个过程是需要”很长的”时间的，在这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。

三、线程的生命周期

• 1.新建状态
• 2.就绪状态
• 3.运行状态
• 4.阻塞状态
• 5.死亡状态
  

2、实现线程的方式

1、继承java.lang.Thread,重写run方法

实现线程的第一种方式：
编写一个类直接继承java.lang.Thread,重写run方法。

怎么创建线程对象？new就行了

怎么启动线程呢？调用线程对象的start()方法就行

public class ThreadTest01 {
    public static void main(String[] args) {
        //这里是一个main方法，这里的代码属于主线程，在主栈中运行。
        //新建一个分支线程对象
        MyThead myThead = new MyThead();
        //启动线程

        //myThead.run();//不会启动线程，不会分配新的分支栈。（这种方式就是单线程）

        //start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，这段代码的任务完成之后，瞬间就结束了。
        //这段代码的任务只是为了开辟一个新的栈空间，只要新的栈空间开辟出来，start()方法就结束了。线程就启动成功了。
        //启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）
        //run方法在分支栈的栈底部，main方法在主栈的底部。run和main是平级的。
        myThead.start();//这行代码是瞬间结束的
        //这里的代码还是运行在主线程中
        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程-->" + i);
        }
    }
}
class MyThead extends Thread{
    @Override
    public void run() {   //必须写
        for (int i = 0; i < 1000; i++) {
            System.out.println("分支线程-->" + i);
        }
    }
}

运行结果：

未注释run()方法的运行结果，此时不是并发：

由上述运行结果发现，有以下特点：有先有后、又多有少。

2、实现java.lang.Runnable接口，实现run方法

实现线程的第二种方式：
编写一个类，实现java.lang.Runnable,重写run方法。

这种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承其他的类，更灵活。

public class ThreadTest02 {
    public static void main(String[] args) {
        //创建一个可运行的对象
        MyRunnable myRunnable = new MyRunnable();
        //将可运行的对象封装成一个线程对象
        Thread t = new Thread(myRunnable);
        //启动线程
        t.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程-->" + i);
        }
    }
}

//这并不是一个线程类，是一个可运行的类。它还不是一个线程。
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("分支线程-->" + i);
        }
    }
}

3、采用匿名内部类的方式

public class ThreadTest03 {
    public static void main(String[] args) {

        //创建线程对象，采用匿名内部类的方式。
        //这是通过一个没有名字的类，new出来的对象。
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    System.out.println("t线程-->" + i);
                }
            }
        });

        //启动线程
        t.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("主线程-->" + i);
        }
    }
}

4、实现Callable接口（JDK8新特性）

该方法效率较低，因为在获取线程的执行结果的时候，当前线程受阻塞。但是可以拿到线程的返回结果

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

public class ThreadTest12 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //第一步：创建一个“未来任务类”接口
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception {//call方法就相当于run方法。只不过这个有返回值
                //线程执行一个任务，执行之后可能会有一个执行结果
                //模拟执行
                System.out.println("call method begin!");
                Thread.sleep(1000 * 10);
                System.out.println("call method end!");
                int a = 100;
                int b = 200;

                return a + b;//自动装箱（300结果变成Integer）
            }
        });

        //创建线程对象
        Thread t = new Thread(task);

        //启动线程
        t.start();

        //这里是main方法，这是在主线程中
        //在主线程中，怎么获取t线程的返回结果？
        //get发方法的执行会导致“当前线程阻塞”
        Object o = task.get();
        System.out.println("线程执行结果：" + o);

        //main方法这里的程序想执行必须等待get()方法的结束
        //而get()方法是为了拿另一个线程的执行结果
        //另一个线程执行是需要时间的
        System.out.println("hello world!");
    }
}

运行结果：

3、获取、修改线程对象的名字

获取当前线程对象：static Thread currentThread()

Thread t = Thread.currentThread();//返回值t就是当前线程
1
public class ThreadTest04 {
    public static void main(String[] args) {
        //创建线程对象
        MyThead2 t = new MyThead2();
        //设置线程的名字
        t.setName("t1");
        //获取线程的名字
        t.getName();
        //启动线程
        t.start();
        String tName = t.getName();
        System.out.println(tName);


        MyThead2 t2 = new MyThead2();
        t2.setName("t2");
        String t2Name = t2.getName();
        System.out.println(t2Name);

        t2.start();
    }
}

class  MyThead2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
        	//currentThread就是当前线程对象。
        	//当t1线程执行run方法，那么这当前线程就是t1；
        	//当t2线程执行run方法，那么这当前线程就是t2；
            Thread currentThread = Thread.currentThread();
            System.out.println( currentThread.getName() + "-->" + i);
        }
    }
}

运行截图：

获取线程对象的名字：String name = 线程对象.getName();

修改线程对象的名字：线程对象.setName("线程名字");

当线程没有设置名字的时候，默认的名字有什么规律？
Thread-0；
Thread-1；
Thread-2…

public class ThreadTest04 {
    public static void main(String[] args) {
        //创建线程对象
        MyThead2 t = new MyThead2();
        //设置线程的名字
        t.setName("tttt");
        //获取线程的名字
        t.getName();
        //启动线程
        t.start();

        String tName = t.getName();
        System.out.println(tName);//如果不设置线程的名字就是：Thread-0

        MyThead2 t2 = new MyThead2();
        System.out.println(t2.getName());//Thread-1
    }
}

class  MyThead2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("分支线程-->" + i);
        }
    }
}

运行结果：

4、线程中的sleep方法详解

1、关于线程的sleep方法

static void sleep(long mills)

• 1、静态方法：Thread.sleep(1000);
• 2、参数是毫秒
• 3、作用：让当前线程进入休眠，进入“阻塞”状态，放弃占有CPU时间片，让给其他线程使用。

public class ThreadTest06 {
    public static void main(String[] args) {
        //让当前线程进入休眠，睡眠5秒
        //当前线程是主线程！！!
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

		//5秒之后执行这里的代码
        System.out.println("hello world!");
    }
}

2、分析哪个线程休眠的

以下代码是让main方法休眠的

public class ThreadTest06 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.setName("t");
        t.start();
        //调用sleep方法
        try {
            //
            t.sleep(1000*5);//在执行过程中还是会被转换为：Thread.sleep(1000*5);
            //这行代码的作用是：让当前的线程进入休眠，也就是说说main线程进入休眠。
            //这样代码出现在main方法中，main线程休眠。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("hello world!");
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

3、终止线程的休眠

sleep睡眠太久了，如果希望半道上醒来，可以使用interrupt()方法
注意：这个不是终断线程的执行，是终止线程的睡眠

public class ThreadTest07 {
    public static void main(String[] args) {

        Thread t = new Thread(new MyRunable2());
        t.setName("t");
        t.start();

        //希望5秒以后，t线程醒来（5秒以后主线程的活干完了）
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //终断t线程的睡眠（这种终断睡眠的方式依靠了java的异常处理机制。）
        t.interrupt();//干扰，一盆冷水过去！！
    }
}

class MyRunable2 implements Runnable{
    //重点：run()当中的异常不能throws，只能try..catch
    //因为run()方法在父类中没有抛出异常，子类不能比父类抛出更多异常。
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--> begin");
        try {
            //睡眠1年
            Thread.sleep(1000*60*60*24*365);
        } catch (InterruptedException e) {
            //打印异常信息
            e.printStackTrace();
        }
        //一年之后才会执行这里
        System.out.println(Thread.currentThread().getName() + "--> end");
    }
}

4、终止线程

强行终止线程

stop()方法，有一个很大的缺点：容易丢失数据。因为这种方式是直接将线程杀死了。
线程没有保存的数据将会丢失。不建议使用。

合理的终止线程

打一个boolean标记

public class ThreadTest08 {
    public static void main(String[] args) {
        Thread t = new Thread();
        MyRunnable4 r = new MyRunnable4();
        t.setName("t");
        t.start();

        //模拟5秒
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //终止线程
        //你想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        r.run = false;
    }
}
class MyRunnable4 implements Runnable{

    //打一个boolean标记
    boolean run = true;

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

            }else {
                //return就结束了，在结束之前还有什么没有保存的。
                //可以在这里保存
                //save....
                return;
            }
        }
    }
}

5、线程调度、线程优先级、线程让位、线程合并

1、关于线程的调度

1.1常见的线程调度模型有哪些? .

• 抢占式调度模型:
  哪个线程的优先级比较高，抢到的CPU时间片的概率就高一些/多一些。
  java采用的就是抢占式调度模型。
• 均分式调度模型:
  平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
  平均分配，一切平等。
  有一些编程语言，线程调度模型采用的是这种方式。

1.2 java中提供了哪些方法是和线程调度有关系的呢?

• 1、实例方法:
  void setpriority (int newPriority)：设置线程的优先级
  int getPriority()：获取线程优先级
  最低优先级1
  默认优先级是5
  最高优先级10
• 2、静态方法:
  static void yield()：让位方法：暂停当前正在执行的线程对象，并执行其他线程

yield()方法不是阻塞方法。让当前线程让位，让给其它线程使用。
yield()方法的执行会让当前线程从**“运行状态”回到“就绪状态”**。
注意：在回到就绪之后，有可能还会再次抢到CPU

• 3、实例方法：
  void join() ：合并线程

class MyThread1 extends Thread {
		public void doSome(){
			Mythread2 t = new MyThread2();
			t,join();//当前线程进入阻塞，t线程执行，知道t线程结束。当前线程才可以继续
		} 	
}
class MyThread2 extends Thread{
}

2、线程优先级

int getPriority()：获取线程优先级

public class ThreadTest09 {
    public static void main(String[] args) {
        System.out.println("最高优先级" + Thread.MAX_PRIORITY);
        System.out.println("最低优先级" + Thread.MIN_PRIORITY);
        System.out.println("默认优先级" + Thread.NORM_PRIORITY);

        //获取当前线程对象，获取当前线程的优先级
        Thread currentThread = Thread.currentThread();
        System.out.println(currentThread.getName() + "线程的默认优先级为：" + currentThread.getPriority());

        Thread t = new Thread(new MyRunnable5());
        t.setName("t");
        t.start();
    }
}

class MyRunnable5 implements Runnable{
    @Override
    public void run() {
        //获取线程优先级
        System.out.println(Thread.currentThread().getName() + "线程的默认优先级为" + Thread.currentThread().getPriority());
    }
}

void setpriority (int newPriority)：设置线程的优先级

public class ThreadTest09 {
    public static void main(String[] args) {

        //设置主线程优先级为1
        Thread.currentThread().setPriority(1);
        //获取当前线程对象，获取当前线程的优先级
        Thread currentThread = Thread.currentThread();
        Thread t = new Thread(new MyRunnable5());
        t.setName("t");
        t.setPriority(10);
        t.start();

        //优先级较高的，只是抢到的CPU的时间片比较多一些。
        //大概率方向更偏向于优先级比较高的。
        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

class MyRunnable5 implements Runnable{
    @Override
    public void run() {

        for (int i = 0; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

3、线程让位

让位：值当前的线程暂停，回到就绪状态，让给其他线程。
静态方法：Thread.yield();

public class ThreadTest09 {
    public static void main(String[] args) {

        Thread t = new Thread(new MyRunnable5());
        t.setName("t");
        t.start();

        for (int i = 1; i < 10000; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

class MyRunnable5 implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 10000; i++) {
            //每100个让位一次
            if (i % 100 == 0){
                Thread.yield();
            }
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

4、线程合并

线程的合并的含义就是将几个并行线程的线程合并为1个单线程执行。应用场景应该是一个线程必须等待另一个线程执行完毕才能使用join方法。

public class ThreadTest09 {
    public static void main(String[] args) {

        System.out.println("main begin");

        Thread t = new Thread(new MyRunnable5());
        t.setName("t");
        t.start();

        //合并线程
        try {
            t.join();//t合并到当前的线程中，当前线程受阻塞，t线程执行直到结束再继续执行main线程。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main over");
    }
}

class MyRunnable5 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

6、synchronized、死锁详解

1、synchronized的三种应用方式

synchronized关键字最主要有以下3种应用方式

• 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁
• 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁
• 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

2、同步代码块(灵活)

线程同步机制的语法是：

synchronized(同步锁)
{
     //线程同步代码块

} 

synchronized后面的小括号中传的这个 “数据”是相当关键 的
这个数据必须是多线程共享的数据。才能达到线程排队。

（）中具体写什么？
那要看想让哪些线程同步。
假设t1、t2、t3、t4、t5，有5个线程。现在只希望t1、t2、t3排队，t4、t5不需要排队。
这时就要在()中写一个t1、t2、t3共享的对象，而这个对象对于t4、t5来说不是共享的。

//this,当前实例对象锁
synchronized(this){
    for(int j=0;j<1000000;j++){
        i++;
    }
}

//class对象锁
synchronized(AccountingSync.class){
    for(int j=0;j<1000000;j++){
        i++;
    }
}

在java语言中,任何一个对象都有“一把锁”,其实这把锁就是标记。( 只是把它叫做锁。)
100个对象, 10把锁。1个对象1把锁。

线程同步的代码的执行原理?

1、假设t1和t2线程并发,开始执行以下代码的时候，肯定有一个先一个后。

2、假设t1先执行了,遇到了synchronized ,这个时候自动找“后面共享对象”的对象锁,找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束,这把锁才会释放。

3、假设t1已经占有这把锁,此时2也遇到synchronized关键字,也会去占有后面共享对象的这把锁,结果这把锁被t1占有, t2只能在同步代码块外面等待t1的结束,直到t1把同步代码块执行结束了, t1会归还这把锁，此时t2终于等到这把锁,然后t2占有这把锁之后，进入同步代码块执行程序。

这样就达到了线程排队。

3、synchronized作用于实例方法

被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

如果多个线程访问同一个对象的实例变量，可能出现非线程安全问题。

使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候 ,其他线程只能在方法外等着.且共享对象一定是this，并且同步代码块是整个方法体。

synchronized public  void  doWork(){

	//  需要同步操作的代码
}
1234

创建了一个AccountingSync对象:

public class AccountingSync implements Runnable{
    //共享资源(临界资源)
    static int i=0;

    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        AccountingSync instance=new AccountingSync();
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

4、synchronized作用于静态方法

表示找类锁。类锁永远只有一把。就算创建了100个对象，那类锁也只有一把。

• 对象锁：1个对象1把锁，100个对象100把锁。
• 类锁：100个对象，也可能只是1把类锁。

当synchronized作用于静态方法时，其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态 成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static synchronized方法，而线程B需要调用这个实例对象所属类的静态 synchronized方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的class对象，而访问非静态 synchronized 方法占用的锁是当前实例对象锁，看如下代码

创建了两个AccountingSyncClass对象：

public class AccountingSyncClass implements Runnable{
    static int i=0;

    /**
     * 作用于静态方法,锁是当前class对象,也就是
     * AccountingSyncClass类对应的class对象
     */
    public static synchronized void increase(){
        i++;
    }

    @Override
    public void run() {
        for(int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        //new新实例
        Thread t1=new Thread(new AccountingSyncClass());
        //new心事了
        Thread t2=new Thread(new AccountingSyncClass());
        //启动线程
        t1.start();t2.start();

        t1.join();t2.join();
        System.out.println(i);
    }
}

由于synchronized关键字修饰的是静态increase方法，与修饰实例方法不同的是，其锁对象是当前类的class对象。注意代码中的increase4Obj方法是实例方法，其对象锁是当前实例对象，如果别的线程调用该方法，将不会产生互斥现象，毕竟锁对象不同，但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。

5、Java三大变量的线程安全

• 实例变量:在堆中。
• 静态变量:在方法区。
• 局部变量:在栈中。

以上三大变量中:

局部变量永远都不会存在线程安全问题。因为局部变量不共享。(一个线程一个栈。)
局部变量在栈中。所以局部变量永远都不会共享。

实例变量在堆中，堆只有1个。

静态变量在方法区中，方法区只有1个。
堆和方法区都是多线程共享的，所以可能存在线程安全问题。

局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。

6、死锁概述

public class ThreadTest10 {
    public static void main(String[] args) {
        Object o1 = new Object();
        Object o2 = new Object();
        Thread t1 = new MyThread1(o1,o2);
        Thread t2 = new MyThread2(o1,o2);
        t1.start();
        t2.start();
    }
}
class  MyThread1 extends Thread{
    Object o1;
    Object o2;
    public MyThread1(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run(){
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(o2){

            }
        }
    }
}
class MyThread2 extends Thread{
    Object o1;
    Object o2;
    public MyThread2(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    @Override
    public void run(){
        synchronized(o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){

            }
        }
    }
}

一直是这样，synchronized在开发中最好不要嵌套使用。一不小心就会导致死锁现象的发生。

7、守护线程和定时器

一、守护线程

1、守护线程概述

Java语言中线程分为两大类：

• 一类是：用户线程
• 一类是：守护线程（后台线程）

其中具有代表性的就是：垃圾回收线程（守护线程）、主线程main（用户线程）

守护线程的特点：
一般守护线程是一个死循环，所有的用户只要结束，守护线程自动结束。

守护线程用在什么地方呢？
每天00:00的时候系统数据自动备份。这个需要使用到定时器，并且我们可以将定时器设置为守护线程。一直在那里看着，每到00:00的时候就备份一次。所有的用户线程如果结束了，守护线程自动退出，没有必要进行数据备份了。

2、实现守护线程

在这里插入代码片public class ThreadTest11 {
    public static void main(String[] args) {

        Thread t = new BakDataThread();
        t.setName("备份数据的线程");

        //启动线程之前，将线程设置为守护线程
        t.setDaemon(true);
        t.start();

        //主线程：主线程是用户线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i) ;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class BakDataThread extends Thread{
    @Override
    public void run(){
        int i = 0;
        while (true){
            System.out.println(Thread.currentThread().getName() + "-->" + (++i));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

运行结果：主线程结束，守护线程就结束，即使是个死循环。

二、定时器

1、定时器概述

定时器的作用:
间隔特定的时间，执行特定的程序。

例如每周要进行银行账户的总账操作。
每天要进行数据的备份操作。

在实际的开发中，每隔多久执行一-段特定的程序，这种需求是很常见的,
那么在java中其实可以采用多种方式实现:

• 可以使用sleep方法，睡眠，设置睡眠时间，没到这个时间点醒来，执行任务。这种方式是最原始的定时器。(比较low)
• 在java的类库中已经写好了一个定时器: java. util.Timer,可以直接拿来用。不过，这种方式在目前的开发中也很少用，因为现在有很多高级框架都是支持定时任务的。
• 在实际的开发中，目前使用较多的是Spring框架中提供的springTask框架,
  这个框架只要进行简单的配置，就可以完成定时器的任务。

2、实现定时器

timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);
也可以使用匿名内部类设定定时任务

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

public class TimerTest {
    public static void main(String[] args) throws Exception{
        //创建定时器对象
        Timer timer = new Timer();
        //Timer timer = new Timer(true);//守护线程的方式

        //指定定时任务
        //timer.schedule(定时任务，第一次执行时间，间隔多久执行一次);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date firstTime = sdf.parse("2021-3-17 11:24:30");
        timer.schedule(new LogTimerTask(),firstTime,1000*10);
    }
}
//编写一个类
//假设这是一个记录日志的定时任务
class LogTimerTask extends TimerTask{
    @Override
    public void run() {
        //编写需要执行的任务就行了。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String strTime = sdf.format(new Date());
        System.out.println(strTime +":成功完成第一次数据备份！");
    }
}

运行结果：

8、wait和notify、生产者和消费者模式

1、关于Object类中的wait和notify方法

即生产者和消费者模式。

• 第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。
  wait方法和notify方法不是通过线程对象调用的，t.wait、t.notify都是不对的
• 第二：wait方法的作用？

Object  o = new Object;
o.wait();

表示：让正在o对象上活动的线程进入等待状态，无限期等待，直到被唤醒为止。o.wait();方法的调用，会让“当前线程（正在o对象上活动的线程）”进入等待状态。

• 第三：notify()方法的作用

Object o = new Object;
o.notify();

表示：唤醒正在o对象上等待的线程。

还有一个notifyAll()方法：唤醒o对象上处于等待的所有下线程

2、生产者和消费者模式

使用wait方法和notify方法实现“生产者和消费者模式”

什么是生产者和消费者模式？

生产线程负责生产，消费线程负责消费。
生产线程和消费线程要达到均衡。
这是一种特殊的业务需求,在这种特殊的情况下需要使用wait方法和notify方法。

• wait和notify方法不是线程对象的方法,是普通java对象都有的方法。
• wait方法和notify方法建立在线程同步的基础之上。因为多线程要同时操作一个仓库。有线程安全问题。
• wait方法作用:o. wait()让正在o对象上活动的线程t进入等待状态，并且释放掉t线程之前占有的o对象的锁。
• notify方法作用:o.notify()让正在o对象上等待的线程唤醒,只是通知,不会释放o对象上之前占有的锁。

模拟这样一个需求:
仓库我们采用list集合。
List集合中假设只能存储一个元素。
1个元素就表示仓库满了。
如果List集合中元素个数是0 ,就表示仓库空了。

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

public class ThreadTest13 {
    public static void main(String[] args) {
        //创建一个仓库对象，共享的
        List list = new ArrayList();
        //创建两个线程对象
        //生产者线程
        Thread t1 = new Thread(new Produce(list));
        //消费者线程
        Thread t2 = new Thread(new Consumer(list));

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

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

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

    public Produce(List list){
        this.list= list;
    }
    @Override
    public void run() {
        //一直生产(使用死循环来模拟一直生产)
        while (true){
            synchronized (list) {
                if (list.size() > 0) {//大于0，说明仓库中已经有1个元素了
                    try {
                        //当前线程进入等待状态，并且释放Producer之前占有的list集合的锁
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序进行到这里，说明仓库是空的，可以生产
                Object obj = new Object();
                list.add(obj);
                System.out.println(Thread.currentThread().getName() + "-->" + obj);

                //唤醒消费者进行消费
                list.notify();
            }
        }
    }
}

//消费线程
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){
                    //仓库已经空了
                    //释放掉Consumer之前占有的锁
                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //程序能够进行到此处说明仓库中有数据，进行消费。
                Object obj = list.remove(0);
                System.out.println(Thread.currentThread().getName() + "-->" + obj);

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

生产一个消费一个的运行结果：