多线程

1、进程的概述及多进程的意义

多任务：一个人边吃饭边玩手机。本质是大脑同一时间只做了一件事。
多线程：一条道路，车比较多，堵塞、效率低。增加车道，提高效率，这就是多线程。

1.1进程和线程

线程是依赖于进程存在的。
比如一个视频进程，它里面就有多个线程：图片、声音、字母等等。

1.2进程（Process）的概述

在操作系统中运行的程序就是进程。比如qq等。
通过任务管理器可以看到进程的存在。

通过观察，发现只有在运行中的程序才会出现进程。

• 进程：就是正在运行的程序。
• 进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存和系统资源。

1.3多进程的意义

• 单进程的计算机只能做一件事情，而我们现在的计算机都可以做多件事情。
• 举例：一边玩游戏（游戏进程），一边听音乐（音乐进程）。
• 现在的计算机都是支持多进程的，可以在一个时间段内执行多个任务，提高CPU的使用率。
• 问题
  对于单核计算机来说，游戏进程和音乐进程是同时运行的吗？
• 不是。因为CPU在某个时间点上只能做一件事情，计算机是在游戏进程和音乐进程间做着频繁切换，且切换速度快。所以让我们感觉是在同时执行。
• 多进程的作用不是提高执行速度，而是提高CPU的使用率。

2、线程的概述和多线程的意义

2.1线程的概述

在一个进程内部又可以执行多个任务，而这每一个任务我们就可以看成是一个线程。

• 线程：是程序的执行单元，执行路径。是程序使用CPU的基本单位。
• 单线程：程序只有一条执行路径。
• 多线程：程序有多条执行路径。

2.2多线程的意义

多线程的作用不是提高执行速度，而是为了提高应用程序的使用率。

理解：
我们的程序在运行的时候，都是在抢CPU的资源（执行权）。

• 多个进程是在抢这个资源，而其中的某一个进程如果执行路径比较多，就会有更高的几率抢到CPU的执行权。
• 也就是说CPU在多线程程序中执行的时间要比单线程多，所以提高了程序的使用率。
• 我们不能保证哪一个线程能够在哪个时刻抢到，所以线程的执行具有随机性。

2.4、线程的创建

1. 通过继承Thread类创建

public class ThreadTest extends Thread{
    //创建线程方式一： 继承Thread类，   重写run方法   调用start开启
    //run方法 线程
    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            System.out.println("我是run方法"+j);
        }
    }
    public static void main(String[] args) {
        //main线程，是主线程
        //创建一个线程对象
        ThreadTest test = new ThreadTest();
        //调用run方法
        //test.run();//就先执行run线程，再执行main主线程
        //调用start方法   开启线程   线程不一定立即执行，由CPU调度安排
        test.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

2. 实现Runnable接口创建

//创建线程方式二：实现runnable接口，重写run方法，执行线程放入runnable接口实现类，调用start方法
public class ThreadTest2 implements Runnable {

    @Override
    public void run() {
        for (int j = 0; j < 100; j++) {
            System.out.println("我是run方法"+j);
        }
    }
    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        ThreadTest2 Test2 = new ThreadTest2();
        //创建线程对象，通过线程对象来开启我们的线程,代理的意思
        Thread thread = new Thread(Test2);
        thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

3. 实现Callable接口（了解）

总结：由于单继承的局限性，推荐使用实现Runnable接口创建线程，灵活方便，方便同一个对象对多个线程使用。
Thread类的基本获取和设置方法
public final String getName()//获取线程名称
public final void setName(String name)//设置线程名称
获取主线程方法：**public static Thread currentThread()**返回对当前正在执行的线程对象的引用。
案例：抢火车票

public class ThreadTest3 implements Runnable {
    //模拟买火车票的案例
    private int num =10;//火车票的数量
    @Override
    public void run() {
        while (true){
            if (num <= 0){//没票就退出
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+num--+"张票");
            //那个线程拿到了第几张票
        }
    }

    public static void main(String[] args) {
        ThreadTest3 test3 = new ThreadTest3();
        //创建三个线程对象
        new Thread(test3,"小芳").start();
        new Thread(test3,"公司张总").start();
        new Thread(test3,"黄牛党").start();
    }
}

案例：龟兔赛跑

//模拟龟兔赛跑
public class ThreadTest4 implements Runnable {
    private static String winner;//定义一个胜利者，并且唯一
    @Override
    public void run() {
        //设定距离是100步
        for (int i = 0; i <= 100; i++) {
            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean b = gameover(i);
            //如果比赛结束了，就停止比赛
            if (b){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    public boolean gameover(int steps){
        //判断是否有胜利者
        if (winner != null){
            return true;
        }else{
            if (steps >=100){
                winner = Thread.currentThread().getName();
                System.out.println("胜利者是："+winner);
                return true;
            }else {
                return false;
            }
        }
    }
    public static void main(String[] args) {
        ThreadTest4 test4 = new ThreadTest4();
        //创建兔子线程和乌龟线程
        new Thread(test4,"兔子").start();
        new Thread(test4,"乌龟").start();
    }
}

3、静态代理模式

比如你要结婚，找婚庆公司帮你布置现场等。
真是对象和代理对象都要实现同一个类。
代理对象要代理真是角色。
代理的好处：

• 代理对象可以做很多真是对象做不了的事
• 真是对象专注于做自己的事

4、Lambda表达式

Lambda表达式使代码变得简洁，避免了内部类定义过多，去掉了一堆没用意义的代码。

函数式接口

任何一个接口，如果里面只有唯一一个抽象方法，这就是一个函数式接口。
函数式接口，我们可以通过lambda表达式来创建该接口对象。

- 正常代码：

public class LambdaTest {
    public static void main(String[] args) {
        Like a = new a();
        a.like(20);
    }
}
//创建一个函数式接口
interface Like{
    void like(int a);
}
//创建实现类
class a implements Like{
    @Override
    public void like(int a) {
        System.out.println("我喜欢你了"+a+"天");
    }
}

• lambda表达式：

public class LambdaTest2 {
    public static void main(String[] args) {
        Like2 love =null;
        love=(int a)-> {
            System.out.println("我喜欢你了"+a+"天");
        };
        love.like2(30);
    }
}
interface Like2{
    void like2(int a);
}

5、线程的五大状态

新生状态：Thread thread = new Thread()创建后,线程对象就进入了新生状态
就绪状态：当线程调用start()方法后，线程就进入录入就绪状态，但不一定立即执行，等待CPU调度
运行状态：进入运行状态，线程才真正开始运行
阻塞状态：当调用sleep()方法、wait时，线程进入阻塞状态，线程不运行，阻塞事件解除后，重新进入就绪状态，等待CPU调度
死亡状态：线程中断或结束的意思。线程一旦进入死亡状态，就不能再次启动

6、线程方法

停止线程

public class ThreadStop implements Runnable{
    public static void main(String[] args) {
        ThreadStop threadstop = new ThreadStop();
        new Thread(threadstop).start();
        for (int j = 0; j < 1000; j++) {
            System.out.println("main线程"+j);
            if (j==900){
                //4、调用stop方法，切换标志位，停止线程
                threadstop.stop();
                System.out.println("线程停止了");
            }
        }
    }
    //1、在线程中定义一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        //2、线程体使用标志位
        int i =0;
        while (flag){
            System.out.println("run线程"+i++);
        }
    }
    //3、这只一个方法停止线程，转换标志位
    public void stop(){
        this.flag=false;
    }
}

线程休眠

slee(时间)方法：指定当前线程阻塞的毫秒数
sleep时间完成后线程进图就绪状态
每个对象都有一个锁，sleep不会释放锁
sleep方法可以放大问题的发生性

• 模拟网络延时

public class ThreadSleep implements Runnable {
    //模拟买火车票的案例
    private int num =10;//火车票的数量

    @Override
    public void run() {
        while (true){
            if (num <= 0){//没票就退出
                break;
            }
            //模拟网络延时
            try {
                Thread.sleep(10);//休眠10毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+num--+"张票");
            //那个线程拿到了第几张票
        }
    }
    public static void main(String[] args) {
        ThreadSleep test3 = new ThreadSleep();
        //创建三个线程对象
        new Thread(test3,"小芳").start();
        new Thread(test3,"公司张总").start();
        new Thread(test3,"黄牛党").start();
    }
}

• 模拟倒计时

//模拟倒计时
public class ThreadSleep2 {
    public static void main(String[] args) throws InterruptedException {
        tenDown();
    }
    //创建一个倒计时方法
    public static void tenDown() throws InterruptedException {
        int num=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <=0){
                break;
            }
        }
    }
}

• 打印系统当前时间

public class ThreadSleep3 {
    public static void main(String[] args) throws InterruptedException {
        //打印系统当前时间
        Date date = new Date(System.currentTimeMillis());//获取系统当前时间
        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));//打印当前时间
            date = new Date(System.currentTimeMillis());//更新当前时间
        }
    }
}

线程礼让

线程礼让：让当前正在执行的线程暂停，但不阻塞。
礼让不一定成功，看CPU调度。

public class ThreadYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"a").start();
        new Thread(myYield,"b").start();
    }
}
class MyYield implements Runnable{

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

线程强制执行（join）

join合并线程，待此线程执行完毕后，再执行其他线程。
与生活中买火车票插队一个意思。

//测试join  
public class ThreadJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("线程老大来了"+i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        ThreadJoin threadJoin = new ThreadJoin();
        Thread thread = new Thread(threadJoin);
        thread.start();
        for (int j = 0; j < 500; j++) {
            if (j == 200){
                thread.join();//插队
            }
            System.out.println("main线程"+j);
        }
    }
}

线程优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级来调度线程执行。
线程的优先级用数字表示，范围是：1~10
Thread.MAX_PRIORITY=10
Thread.MIN_PRIORITY=1
Thread.NORM_PRIORITY=5
获取线程的优先级：getPriority();
设置线程优先级：setPriority（int XXX）

public class ThreadPriority {
    public static void main(String[] args) {
        //打印主线程默认优先级
        System.out.println(Thread.currentThread().getName() + "===" + Thread.currentThread().getPriority());
        //创建线程对象
        MyPriority myPriority = new MyPriority();
        Thread thread1 = new Thread(myPriority);
        Thread thread2 = new Thread(myPriority);
        Thread thread3 = new Thread(myPriority);
        Thread thread4 = new Thread(myPriority);
        Thread thread5 = new Thread(myPriority);
        //设置优先级  先设置，后启动
        thread1.start();
        thread2.setPriority(1);
        thread2.start();
        thread3.setPriority(8);
        thread3.start();
        thread4.setPriority(Thread.MAX_PRIORITY);//Thread.MAX_PRIORITY 最高优先级 10
        thread4.start();
        thread5.setPriority(4);
        thread5.start();
    }
}
class MyPriority implements Runnable {
    @Override
    public void run() {
        //打印线程的名字和线程的优先级
        System.out.println(Thread.currentThread().getName() + "===" + Thread.currentThread().getPriority());
    }
}

守护线程（daemon）

分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
tg.setDaemon(true);设置守护线程。默认是false，表示用户线程，证常的都是用户线程，当传入true时，变为守护线程

//守护线程
//比如上帝守护你
public class ThreadDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        Thread tg = new Thread(god);
        //设置守护线程   默认是false，表示用户线程，证常的都是用户线程，当传入true时，变为守护线程
        tg.setDaemon(true);
        tg.start();//守护线程启动
        new Thread(you).start();
    }
}
//上帝
class God implements Runnable{
    @Override
    public void run() {
        System.out.println("上帝守护着众生");
    }
}
//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 30000; i++) {
            System.out.println("自己开心的活着");
        }
        System.out.println("goodbye world");
    }
}

7、线程同步

多个线程同步同一个资源。
并发：同一个对象被多个线程同时操作。
线程同步形成的条件：队列+锁。比如：排队上厕所，厕所门上有锁，为了保证安全性。

锁机制 synchronize

有一张票，三个人去买，如果都卖到了票，就会出现负数。所以引入了synchronize关键字，确保数据的正确性。
一个线程有锁会导致其他所有需要此锁的线程等待。
加锁会影响性能。
优先级高的线程等待优先级低的线程释放锁，会导致优先级导致，引起性能问题。
synchronize的两种用法：
锁的对象是变化的量，需要需改的

• synchronize方法
  锁用在方法上，则锁的是调用者 this，而不是方法本身。
• synchronize块

死锁

当多个线程都拿着对方需要的资源（锁），这就形成了死锁。
比如：有一个镜子和口红，两个女生都想化妆，一个女生先拿到了镜子，等口红。另一个女生先拿到了口红，等镜子。这就是死锁的意思。
产生死锁的额必要条件

1. 互斥条件：一个资源每次只能被一个进程使用
2. 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3. 不剥夺条件：进程已获得资源，在未使用完之前，不能强行剥夺。
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
   只要解决上述四种条件的一种或多种，就可以避免死锁。

Lock锁（同步锁）

JDK5.0提供

public  class TestLock implements Runnable{
    public static void main(String[] args) {
        TestLock lock = new TestLock();
        new Thread(lock).start();
        new Thread(lock).start();
        new Thread(lock).start();
    }
    int tickerNums =10;//定义车票数量
    private final ReentrantLock reentrantLock = new ReentrantLock();//定义lock锁
    @Override
    public void run() {
        while (true){
            try {
                reentrantLock.lock();//加锁
                if (tickerNums >0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("车票数"+tickerNums--);
                }else {
                    break;
                }
            }finally {
                reentrantLock.unlock();//解锁
            }
        }
    }
}

8、线程协作

应用场景：生产者和消费者问题
解决线程之间通信问题的方法：
wait();表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long timeout);指定等待的毫秒数
notify();唤醒一个处于等待状态的线程
notifyAll();唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度
解决方式

1. 管程法
   生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据。

//测试生产者消费者问题   方法一：利用缓冲区解决，也就是管程法
//需要：生产者  消费者   产品  缓冲区
public class TestPc {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new productor(container).start();
        new Consumer(container).start();
    }
}
//生产者
class productor extends Thread {
    SynContainer container;

    public productor(SynContainer container) {
        this.container = container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");
        }
    }
}
//消费者
class Consumer extends Thread {
    SynContainer container;
    public Consumer(SynContainer container) {
        this.container = container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了" + container.pop().id + "只鸡");
        }
    }
}
//产品
class Chicken {
    int id;//产品编号
    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer {
    //需要一个容器
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;
    //生产者放入产品
    public synchronized void push(Chicken chicken) {
        //如果容器满了，就需要等待消费者消费
        if (count == chickens.length) {
            //通知消费者消费，生产者等待
            try {
                this.wait();//让生产者等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
            //如果没有满，我们就需要放入产品
            chickens[count] = chicken;
            count++;
        
        //有鸡后，就可以通知消费者消费
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized Chicken pop() {
        //判断能否消费
        if (count == 0) {
            //等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //消费者可以消费
        count--;//消费者消费
        Chicken chicken = chickens[count];
        //吃完了，通知生产者生产
        this.notifyAll();
        return chicken;
    }
}

2. 信号灯法

//信号灯法 标志位解决
public class TestPc2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();

    }
}
//生产者  演员
class Player extends  Thread{
    TV tv;
    public Player(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i%2 == 0){
                this.tv.play("NBA");
            }else {
                this.tv.play("吐槽大会");
            }
        }
    }
}
//消费者  观众
class Watcher extends  Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            this.tv.watch();
        }
    }
}

//产品    节目
class TV{
    //演员表演，观众等待  t
    //观众观看，演员等待  f
    String video;//表演的节目
    boolean flag= true;//设置一个标志位

    //表演
    public synchronized void play(String video){
        if (!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演："+video);
        //通知观众观看
        this.notifyAll();
        this.video =video;
        this.flag= !this.flag;
    }
    //观看
    public synchronized void watch(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了："+video);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

9、线程池

Executors：工具类，用于创建并返回不同类型的线程池

public class TestPool {
    public static void main(String[] args) {
        //1、创建服务、创建线程池
        ExecutorService service = Executors.newFixedThreadPool(5);

        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2、关闭链接
        service.shutdown();
    }
}
class MyThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}