2021-07-22

多线程

概念：多线程，说白了就是多条执行路径，原来是一条路径，就主路径(main)，现在是多 条路径。
特性：三高：高可用、高性能、高并发；
优点：提高效率

线程

线程是程序中执行的线程。 Java虚拟机允许应用程序同时运行多个执行线程。

进程

执行中的程序叫做进程(Process)，是一个动态的概念。
进程与线程的区别：
进程: 系统中的应用程序,一个进程之间包含1~n个线程,进程具有自己的资源,内存空间,进程是资源分配的最小单位
线程: 一个程序中的顺序流,多个线程共享一个进程的资源和数据空间,每一个线程具有自己的程序计数器,线程是cpu调度的最小单位

线程的创建：

继承Thread,重写run()方法,定义线程体 + start()

public class Thread extends Thread{
    public static void main(String[] args) {
        //创建线程
        Class001_Thread th = new Thread();
        //开启线程 start() 可以被cpu调度了
        th.start();
        for(int i=1;i<=20;i++){
            System.out.println("一边讲课....");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    /*
        run() 定义线程体
     */
    @Override
    public void run() {
        for(int i=1;i<=20;i++){
            System.out.println("一边喝水....");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

实现Runnable接口,重写run()方法 + start() --> 推荐
1.类是单继承,接口多实现
2.可以实现资源共享

public class Thread implements Runnable{
    public static void main(String[] args) {
        //创建线程
        Thread th = new Thread(new Thread());

        //开启线程
        th.start();
        //new Thread().run();  //方法的调用,不是线程的开启
        for(int i=1;i<=20;i++){
            System.out.println("一边陪女朋友");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /*
        定义线程体
     */
    @Override
    public void run() {
        for(int i=1;i<=20;i++){
            System.out.println("一边打游戏");
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

juc包下Callable接口,重写call()方法
1.call可以抛出异常
2.可以定义返回值

public class Racer implements Callable<Integer> {
    //赢的参赛者名字
    private String winner = null;

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //一场比赛
        Racer racer = new Racer();

        //1.创建执行服务
        ExecutorService server = Executors.newFixedThreadPool(2);
        //2.提交任务
        Future<Integer> future1 = server.submit(racer);
        Future<Integer> future2 = server.submit(racer);
        //3.获取结果
        System.out.println(future1.get());
        System.out.println(future2.get());

        //3.终止服务
        server.shutdown();
    }
    @Override
    public Integer call() {
        for(int steps=1;steps<=100;steps++){
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"正在第"+steps+"步...");
            //判断是否为兔子每跑十步休息一下 100毫秒
            if("pool-1-thread-1".equals(Thread.currentThread().getName()) && steps%10==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //游戏是否结束,是否有参赛者赢了
            if(checkOver(steps)){
                return steps;
            }
        }
        return null;
    }
    /**
     * 检查游戏是否结束
     * @param steps 当前参赛者的步数
     * @return 是否结束
     *      true-->结束
     *      false -->不结束
     */
    private boolean checkOver(int steps) {
        if(winner!=null){
            return true;
        }
        if(steps==100){
            winner = Thread.currentThread().getName();
            return true;
        }
        return false;
    }
}

线程的状态：

    新生状态 : new Thread(),当前线程处于新生状态
    就绪状态 : start(),这个线程进入就绪状态,线程准备好可以被cpu调度,会进入到就绪队列,等待cpu的调度
    运行状态 : 当cpu调度到这个线程,线程进入到运行状态开始执行
    阻塞状态 : 当程序无法正常执行(进入阻塞状态的多种方式...)
    终止状态 : 线程结束
   		 1.一个线程一旦终止,无法恢复
   		 2.一个线程如果进入阻塞状态,阻塞接触会直接恢复到就绪状态
    进入到阻塞状态的几种方式 :
        1. sleep()
        2. join()
        3. wait()
        4. IO
    进入线程就绪状态的方式:
        1. start()
        2. yield()
        3. 线程切换
        4. 阻塞接触
    进入终止状态的方式:
        1.stop 已经过时,不推荐使用    2.正常之间完毕       3.添加标识判断  --> 推荐
    sleep(ms) :  1s = 1000ms
        线程休眠|睡眠
        会进入到阻塞状态,当指定的ms数结束,线程会恢复到就绪状态
        抱着资源睡觉
        让出cpu的资源
        抱着是指对象的资源|锁
    作用 :
        1) 模拟网络延迟
        2) 方法问题的可能性

yield 礼让线程
当一个线程调用yield,让出cpu的资源,进入到就绪状态
静态方法

public class Yield implements Runnable{
    public static void main(String[] args) {
        new Thread(new Yield(),"A").start();
        new Thread(new Yield(),"B").start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始了");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"结束了");
    }
}

join() 插队线程
join(ms) 插队指定的休眠时间数
成员方法join,线程对象.join() 当前线程对象插队
注意: 先就绪,后插队

public class Join {
    public static void main(String[] args) {
        new Thread(new Father()).start();
    }
}
//父亲线程
class Father implements Runnable{
    @Override
    public void run() {
        System.out.println("想抽烟了...");
        System.out.println("给儿子钱,让他去买烟....");
        //创建儿子线程
        Thread th = new Thread(new Son());
        //开启线程
        th.start();
        //插队
        try {
            th.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("接过烟,吸一口...");
        System.out.println("把零花钱给儿子....");
    }
}
class Son implements Runnable{
    @Override
    public void run() {
        System.out.println("接过钱,去买烟");
        System.out.println("路上遇到一家游戏厅,进去玩10s钟...");
        for(int i = 10;i>=0;i--){
            System.out.println(i+"s过去了");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("赶紧去买烟...");
        System.out.println("把烟递给老爸,然后把钱给他...");
    }
}

方法：
void interrupt() 为线程添加一个中断标识
boolean isInterrupted() 测试此线程是否已被中断,是否已经调用过interrupt()方法添加中断标识,是->true不是->false
static boolean interrupted() 测试当前线程是否已被中断, 是否已经调用过 interrupt()方法添加中断标识,是->true 不是->false,同时会复位标识
注意: 一个线程如果进入终止状态,线程的中断标识会复位
sleep： InterruptedException - 如果有任何线程中断了当前线程。 抛出此异常时，将清除当前线程的中断状态 。
getState() 获取当前线程的状态
Thread.State 线程状态。 线程可以处于以下状态之一：
NEW：尚未启动的线程处于此状态。
RUNNABLE：在Java虚拟机中执行的线程处于此状态。
BLOCKED：被阻塞等待监视器锁定的线程处于此状态。多线程操作下,处于等待对象锁的线程处于这种状态
WAITING：无限期等待另一个线程执行特定操作的线程处于此状态。 wait(),join()
TIMED_WAITING：正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。阻塞与时间相关的线程处于这种状态 sleep(ms),join(ms),wait(ms)
TERMINATED： 已退出的线程处于此状态。
Priority 线程的优先级
线程的优先级越高,有限执行的可能性越大
1~10 线程优先级的数值范围
默认5 NORM_PRIORITY
最小1 MIN_PRIORITY
最大10 MAX_PRIORITY
setPriority(int) 设置一个线程的优先级
getPriority() 获取一个线程的优先级
线程:
用户线程
守护线程
守护线程就是用来守护用户线程,当程序中所有的用户线程全部执行完毕,守护线程会直接结束
setDaeson(true) 设置守护线程
isDaeson() 判断线程是否为守护线程
现在所创建的线程默认都是用户线程
垃圾回收机制典型的守护线程

public class Daemon{
    public static void main(String[] args) {
        Thread th = new Thread(()->{
            int i = 1;
            while(true){
                System.out.println("守护线程"+i++);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        /*设置为守护线程*/
        th.setDaemon(true);
        //开启线程
        th.start();
        for(int i=100;i<=110;i++){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
        System.out.println("主线程执行完毕");
    }
}

线程安全问题:

多线程同时操作同一份资源才有可能遇到线程不安全问题
同步锁: 让关键重点代码排队执行,其他代码依旧同时执行,在提高效率的基础上保证数据安全
synchronized 关键字
    关注点:
        1.限制条件: 对象锁(每一个对象只有一把锁) 锁哪一个对象能锁住
        2.同步的代码范围: 范围太大,效率低,范围太小,容易锁不住
   使用方式:
        同步方法
            静态方法
                排队执行的代码范围： 方法体
                锁的对象 ： 锁类
            成员方法 :
                排队执行的代码范围： 方法体
                锁的对象 ： 调用成员方法的对象
        同步块
            synchronized(锁的对象){
                排队执行的代码；
            }
            锁的对象 ： this  类：类的Class对象   资源
        同步方法特点:
            1.简单
            2.范围太大,效率低

public class Web12306 implements Runnable{
    Tickets tickets = new Tickets();  //自定义引用数据类型的对象

    public void run() {
        //重复买票
        while(true){
            synchronized (Web12306.class){//同步块
                if(tickets.num<=0){
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"正在购买第"+ tickets.num-- +"张票");

               try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            /*多次购买之间休眠一定时间*/
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        Class004_Web12306 web = new Web12306();
        //创建线程
        Thread th1 = new Thread(new Web12306(),"小敏");
        Thread th2 = new Thread(new Web12306(),"小明");
        Thread th3 = new Thread(new Web12306(),"小美");

        th1.start();
        th2.start();
        th3.start();
    }
}

线程通信

多线程之间打成通信沟通的效果,协作完成业务需求
Object:
wait() 线程等待 当调用某一个对象 的wait方法,当前线程就会进入到与这个对象相关的等待池中进行等待—>等待阻塞,等待被唤醒
会让出cpu的资源,并且会释放对象的锁
notify() 唤醒线程 当调用一个对象的notify方法,会唤醒当前对象等待池中正在等待的线程,唤醒某一个
这个线程会进入到就绪状态,要想要运行: 1)cpu的调度 2)获取对象锁
wait(ms) 阻塞等待指定时间
notifyAll() 唤醒全部
wait与notify必须使用在一个同步环境下,用于控制多线程之间协调工作问题,保证数据安全
sleep与wait之间区别
sleep : 线程休眠 抱着资源睡觉: 让出cpu资源,抱着对象的锁

public class Class001_Wait {
    public static void main(String[] args) {
        Street street = new Street(); //共享街道
        new Thread(new Person(street)).start();
        new Thread(new Car(street)).start();
    }
}

//街道
class Street{
    //红绿灯
    private boolean flag = false;

    //ns
    public synchronized void ns(){
        //判断是否为绿灯
        if(flag){
           /* try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            System.out.println("人走......");
            //红绿灯变为红灯
            flag=false;
            //唤醒对方线程
            this.notify();
            //自己等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    //we
    public synchronized void we(){
        if(!flag){
            /*try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            System.out.println("车走......");
            //红绿灯变为红灯
            flag=true;
            //唤醒对方线程
            this.notify();
            //自己等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//人
class Person implements Runnable{
    //街道
    private Street street = null;

    public Person(Street street) {
        this.street = street;
    }

    @Override
    public void run() {
        while(true){
            street.ns();
        }
    }
}

//车
class Car implements Runnable{
    //街道
    private Street street = null;

    public Car(Street street) {
        this.street = street;
    }

    @Override
    public void run() {
        while(true){
            street.we();
        }
    }
}