Java多线程（引用--＞狂神学习笔记）2021-09

狂神说多线程笔记整理

笔记总结来自狂神说Java多线程详解

一、线程简介

1. 多任务

现实中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。

2. 多线程

原来是一条路，慢慢因为车太多了，道路阻塞，效率极低。为了提高使用的效率，能够充分利用道路，于是加了多个车道。从此，妈妈再也不用担心道路阻塞了。

3. 程序.进程.线程

4. Process与Thread

• 说起进程,就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

• 而进程则是执行程序的依次执行过程，它是一个动态的概念。是系统资源分配的单位。

• 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的单位。

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

5. 核心概念

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

二、线程实现

1. 线程创建（三种方法）

2.1 继承Thread类(重要)

自定义线程类继承Thread类

重写run()方法，编写线程执行体

创建线程对象，调用start()方法启动线程

实现

public class threadTest extends Thread {
   
    @Override
    public void run() {
   
        for (int i = 0; i < 200; i++) {
   
            System.out.println("我在听音乐"+i);
        }
    }
    public static void main(String[] args) {
   
        //main线程，上线程
        //创建一个线程对象
        threadTest threadTest = new threadTest();
        //调用start（）开启线程
        threadTest.start();
        for (int i = 0; i < 1000; i++) {
   
            System.out.println("我正在跑步！"+i);
        }
    }
}

总结：

线程不一定立即执行，CPU安排调度
案例：(下载图片)

案例

public class threadTest2 extends Thread {
   
    private String url;
    private String name;

    public threadTest2(String url,String name){
   
        this.url = url;
        this.name = name;
    }

    public void run(){
   
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了图片:"+name);
    }

    public static void main(String[] args) {
   
        threadTest2 t1 = new threadTest2("https://img2.woyaogexing.com/2021/09/04/0c9aaf692bb3428b991d370741f643fd!400x400.jpeg","1.jpg");
        threadTest2 t2 = new threadTest2("https://img2.woyaogexing.com/2021/09/04/fafaba4f486d406ba8eeffc0ecce6f31!400x400.jpeg","2.jpg");
        threadTest2 t3 = new threadTest2("https://img2.woyaogexing.com/2021/09/04/5e0e7b364d2547d5a4c61e80c35e4eb6!400x400.jpeg","3.jpg");
        t1.start();
        t2.start();
        t3.start();
    }
}
class  WebDownloader{
   
    public void downloader(String url,String name){
   
        try {
   
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
   
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题~~");
        }
    }
}

2.2 实现Runnable接口

推荐使用Runnable对象,因为Java单继承的局限性

自定义线程类实现Runnable接口

实现run()方法,编写线程执行体

创建线程对象,调用start()方法启动对象

实现

public class threadTest3 implements Runnable {
   
    //run方法线程体
    public void run() {
   
        for (int i = 0; i < 200; i++) {
   
            System.out.println("我在听音乐"+i);
        }
    }
    public static void main(String[] args) {
   
        //创建runnable接口的实现类对象
        threadTest3 threadTest3 = new threadTest3();
        //创建线程对象，通过线程对象开启我们的线程
//        Thread thread = new Thread(threadTest3);
//        thread.start();
        new Thread(threadTest3).start();
        for (int i = 0; i < 1000; i++) {
   
            System.out.println("我正在跑步！"+i);
        }
    }
}

案例

火车票:

//发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class threadTest4 implements Runnable {
   
    //火车票
    private int ticket = 10;

    public void run() {
   
        while (true){
   
            if (ticket<=0)break;
            try {
   
                Thread.sleep(1500);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第"+ ticket-- +"张票");
        }
    }

    public static void main(String[] args) {
   
        threadTest4 threadTest4 = new threadTest4();

        new Thread(threadTest4,"树荫").start();
        new Thread(threadTest4,"老师").start();
        new Thread(threadTest4,"黄牛").start();
    }
}

龟兔赛跑:

public class Race implements Runnable {
   
    private String winner = null;
    public void run() {
   
        for (int i = 0; i <= 101; i++) {
   
            if (Thread.currentThread().getName().equals("兔子")&& i % 10==0){
   
                try {
   
                    Thread.sleep(1);
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
            if (gameOver(i))break;
        }
    }
    private boolean gameOver(int steps){
   
        if(winner!=null){
   
            return true;
        }else {
   
            if(steps>=100){
   
                winner = Thread.currentThread().getName();
                System.out.println("winner is"+winner);
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
   
        Race race = new Race();
        new Thread(race,"乌龟").start();
        new Thread(race,"兔子").start();
    }
}

2.3 实现Callable接口（了解）

实现Callable接口，需要返回值类型

重写call方法，需要抛出异常

创建目标对象

创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);

提交执行：Future result1 = ser.submit(11);

获取结果：boolean r1 = result1.get()

关闭服务：ser.shutdownNow();

实现

/**
 * 实现Callable接口
 */
public class TestCallable implements Callable<Boolean> {
   
    private String url;
    private String name;
	//有参构造
    public TestCallable(String url,String name){
   
        this.url = url;
        this.name = name;
    }
	//下载图片线程的执行体
    public Boolean call() throws Exception {
   
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了图片:"+name);
        return true;
    }
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
   
        TestCallable t1 = new TestCallable("https://img2.woyaogexing.com/2021/09/04/0c9aaf692bb3428b991d370741f643fd!400x400.jpeg","1.jpg");
        TestCallable t2 = new TestCallable("https://img2.woyaogexing.com/2021/09/04/fafaba4f486d406ba8eeffc0ecce6f31!400x400.jpeg","2.jpg");
        TestCallable t3 = new TestCallable("https://img2.woyaogexing.com/2021/09/04/5e0e7b364d2547d5a4c61e80c35e4eb6!400x400.jpeg","3.jpg");

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
        //获取结果：
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        System.out.println(rs1);
        System.out.println(rs2);
        System.