多线程学习

线程简介

普通方法调用和多线程的描述图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uTXvjxvx-1628690481304)(C:\Users\ZYH.LAPTOP-32L7159T\AppData\Roaming\Typora\typora-user-images\image-20210809153217479.png)]

程序、进程、线程：

在操作系统中运行的程序就是进程，比如你的QQ，播放器、游戏、IDE等等。

一个进程可以有多个线程，如视频中同时听声音，看图像，看弹幕等等。

Process与Thread:

• 说起进程，就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
• 而进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位。
• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

**注意：**很多多线程是模拟出来的，真的的多线程是指有多个CPU,即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。

核心概念

• 线程就是独立的执行路径；
• 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
• main()称为主线程，为系统的入口，用于执行整个程序；
• 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的；
• 对同一份资源操作时，会存在资源抢夺问题，需要加入并发控制；
• 线程会带来额外的开销，如CPU调度时间，并发控制开销；
• 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

有以下三种方式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BFsStzWZ-1628690481309)(C:\Users\ZYH.LAPTOP-32L7159T\AppData\Roaming\Typora\typora-user-images\image-20210809154901167.png)]

目前先重点学习前两种。

1.继承Thread类,步骤如下

• 自定义线程类继承Thread类
• 重写run()方法，编写线程执行体
• 创建线程对象，调用start()方法启动线程，不能调用run（）方法，调用run（）方法会使程序先去把run()方法执行完才会往下走，此外线程开启不一定立刻执行，由cpu调度执行。

package com.zyh.demo01;

/**
 * @author ZYH
 * @description 线程测试继承Thread类，重写run方法，调用start开启线程
 * @date 2021/8/9 15:55
 */

//总结：注意，线程开启不一定立刻执行，由cpu调度执行

public class TestThread01 extends Thread {
    @Override
    public void run(){
        for (int i = 0;i<20;i++){
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        //主线程

        TestThread01 testThread01 = new TestThread01();
        testThread01.start();
        for (int i=0;i<20;i++){
            System.out.println("我在学习多线程"+i);
        }
    }
}

2.实现runnable接口：

• 自定义线程类实现runnable接口
• 实现run方法，编写线程执行体
• 创建线程对象，通过线程对象来开启我们的线程，代理

package com.zyh.demo01;

/**
 * @author ZYH
 * @description 实现runnable接口,重写run方法，调用start方法。
 * @date 2021/8/9 16:34
 */
public class TestThread03 implements Runnable{
    @Override
    public void run(){
        for (int i = 0;i<20;i++){
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        //主线程
        TestThread03 testThread03 = new TestThread03();

        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread03);
		//new Thread(testThread03).start();
        thread.start();

        for (int i=0;i<20;i++){
            System.out.println("我在学习多线程"+i);
        }
    }
}

推荐使用runnable接口：避免单继承局限性，灵活方便，方便同一个被多个线程使用

Lamda表达式

为了简化：

new Thread(()->System.out.println("多线程学习")).start();

• λ 希腊字母表中排序第十一位的字母，英语名称为 Lamda
• 避免匿名内部类定义过多
• 其实质属于函数式编程的概念
• 去掉了一堆没有意义的代码,只留下核心逻辑

函数式接口的定义：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

public interface Runnable{
    public abstract void run();
}

对于函数式接口，我们可以通过Lamda表达式来创建该接口的对象。

public class Demo14_LamdaCase2 {
    public static void main(String[] args) {
        // 1.lamda
        ILove love = (int a) -> {
            System.out.println("I love you -->" + a);
        };
        // 2.lamda简化1.0
        love = (a) -> {
            System.out.println("I love you -->" + a);
        };
        // 3.lamda简化2.0
        love = a -> {
            System.out.println("I love you -->" + a);
        };
        // 3.lamda简化3.0
        love = a -> System.out.println("I love you -->" + a);

        /**总结:
         * {}简略的条件是只能有一行代码,多行{}就不能简略了
         * 前提是接口为函数式接口(只能有一个方法)
         * 多个参数也可以去掉参数类型,要去掉就都去掉,必须加上()
         */

        love.love(520);
    }
}

interface ILove {
    void love(int a);
}

五种状态：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9xDFCwhC-1628690481312)(D:\study\Typora\images\Thread.png)]

停止线程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3nU3OH52-1628690481316)(D:\study\Typora\images\Thread停止.png)]

/**
 * 测试stop
 * 1.建议线程正常停止-->利用次数,不建议死循环
 * 2.建议使用标志位-->设置一个标志位
 * 3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
 */
public class Demo15_StopThread implements Runnable {
    // 1. 设置一个标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run...Thread" + i++);
        }
    }

    // 2. 设置一个公开的方法停止线程,转换标志位
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        Demo15_StopThread stop = new Demo15_StopThread();
        new Thread(stop).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main..." + i);
            if (i == 900) {
                //调用stop()切换标志位,让线程终止
                stop.stop();
                System.out.println("该线程停止了");
            }
        }
    }
}

主要是通过设置一个标志位，然后自定义stop方法，停止线程。

线程休眠

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hdDMyb1M-1628690481319)(D:\study\Typora\images\ThreadSleep.png)]

线程礼让

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-olUdbCDr-1628690481322)(D:\study\Typora\images\ThreadYield.png)]

线程插队（少使用，其它线程堵塞）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sEFAqiaG-1628690481324)(D:\study\Typora\images\ThreadJoin.png)]

线程优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tLTKspFp-1628690481326)(D:\study\Typora\images\ThreadPriority.png)]

守护线程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ojA7G7ST-1628690481328)(D:\study\Typora\images\ThreadDaemon.png)]

线程同步机制

多个线程操作同一个资源，就需要注意线程同步的问题。

例如：上万人抢100张票；排队吃饭。

队列和锁

线程同步的形成条件：队列和锁 （synchronized）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TNGYbzce-1628690481330)(D:\study\Typora\images\synchronized.png)]

同步方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JR4Rs1z4-1628690481333)(D:\study\Typora\images\synchronized2.png)]

死锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6aasrMnA-1628690481335)(D:\study\Typora\images\dieSynchronized.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ESTOKubJ-1628690481337)(D:\study\Typora\images\deadLock.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RlmLJokF-1628690481339)(D:\study\Typora\images\LockTest.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LSagnV8C-1628690481340)(D:\study\Typora\images\synchronizedAndLock.png)]

线程协作

生产者消费者问题

wait和notify来解决生产者消费者问题。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1fBHcd2u-1628690481342)(D:\study\Typora\images\ProductAndCostum.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EMLe5op7-1628690481344)(D:\study\Typora\images\PC2.png)]

管城法：

/**
 * 测试:生产者消费者模型-->利用缓冲区解决:管程法
 */
public class Demo33_ThreadPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Producer(synContainer).start();
        new Consumer(synContainer).start();
    }
}

//生产者
class Producer extends Thread {
    //容缓冲区
    SynContainer container;

    public Producer(SynContainer container) {
        this.container = container;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Product(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 Product {
    int id;//产品编号

    public Product(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer {
    //需要一个容器大小
    Product[] products = new Product[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Product product) {
        //如果容器满了,需要等待消费者消费
        /*如果是if的话，假如消费者1消费了最后一个，这是index变成0此时释放锁被消费者2拿到而不是生产者拿到，这时消费者的wait是在if里所以它就直接去消费index-1下标越界，如果是while就会再去判断一下index得值是不是变成0了*/
        while (count == products.length) {
            //通知消费者消费,等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满,需要丢入产品
        products[count] = product;
        count++;
        //通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Product pop() {
        //判断是否能消费
        while (count <= 0) {
            //等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Product product = products[count];
        //吃完了 通知生产者生产
        this.notifyAll();
        return product;
    }
}

信号灯法：

/**
 * 测试:生产者消费者模型-->利用缓冲区解决:管程法
 */
public class Demo33_ThreadPC {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Producer(synContainer).start();
        new Consumer(synContainer).start();
    }
}

//生产者
class Producer extends Thread {
    //容缓冲区
    SynContainer container;

    public Producer(SynContainer container) {
        this.container = container;
    }

    //生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.push(new Product(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 Product {
    int id;//产品编号

    public Product(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer {
    //需要一个容器大小
    Product[] products = new Product[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Product product) {
        //如果容器满了,需要等待消费者消费
        /*如果是if的话，假如消费者1消费了最后一个，这是index变成0此时释放锁被消费者2拿到而不是生产者拿到，这时消费者的wait是在if里所以它就直接去消费index-1下标越界，如果是while就会再去判断一下index得值是不是变成0了*/
        while (count == products.length) {
            //通知消费者消费,等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满,需要丢入产品
        products[count] = product;
        count++;
        //通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Product pop() {
        //判断是否能消费
        while (count <= 0) {
            //等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Product product = products[count];
        //吃完了 通知生产者生产
        this.notifyAll();
        return product;
    }
}

线程池

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TKKxP6nj-1628690481346)(D:\study\Typora\images\ThreadPool.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zQ49O6jn-1628690481347)(D:\study\Typora\images\Pool2.png)]

//测试线程池
public class Demo35_ThreadPool {
    public static void main(String[] args) {
        // 1. 创建服务,擦行间线程池
        // newFixedThreadPool(线程池大小)
        ExecutorService service = Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //关闭连接
        service.shutdown();
    }
}

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

ice service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//关闭连接
service.shutdown();
}
}

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