多线程

GitHub - SoftLeaderGy/StartThread

一、线程的相关简介

二、线程的创建（Thread、Runnable）

（Thread、Runnable、Callable）

1、方式一（继承Thread类）

步骤：

继承Thread类
重写run()方法
主线程调用start()方法开启线程

总结：

线程开启不一定立即执行，由cpu就行调度

代码：

/**
 * 创建线程类
 * 重写run（）方法
 * 调用start开启线程
 */
public class TestThread01 extends Thread{
    @Override
    public void run() {
        // run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码--" + i);
        }
    }
    public static void main(String[] args) {
        // 创建一个线程对象
        TestThread01 testThread01 = new TestThread01();
        // 调用start方法开启线程
        testThread01.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习--" + i);
        }
    }
}

2、方式二（实现Runnable）

步骤：

实现Runnable接口具有多线程的能力
启动线程：传入目标对象 + Thread对象.start()

代码

package com.yang.demo01;
/**
 * 实现Runnable接口，实现多线程
 * 实现Runnable接口、重写run方法、执行线程需要丢入Runnable接口的实现类、调用start方法
 */
public class TestThread03 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("我在看书 -->" + i);
        }
    }
    public static void main(String[] args) {
        TestThread03 testThread03 = new TestThread03();
        // 开启线程
        new Thread(testThread03).start();
        for (int i = 0; i < 100; i++) {
            System.out.println("我在学习 -->" + i);
        }
    }
}

总结
○推荐使用:避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用

三、初识并发问题

买票案例（10张车票，三个人同时买票）
代码

package com.yang.demo01;
public class TestThread04 implements Runnable{
    // 定义车票一共100张票
    private int TICKET = 10;
    @Override
    public void run() {
        while (true) {
            if(TICKET <= 0){
               break;
            }
            // 电脑速度过快，添加延时
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "抢到了第--->"+ TICKET-- + "张票");
        }
    }
    public static void main(String[] args) {
        TestThread04 testThread04 = new TestThread04();
        new Thread(testThread04,"小明").start();
        new Thread(testThread04,"小李").start();
        new Thread(testThread04,"小王").start();
    }
}

发现问题

多个线程操作同一个资源的情况下，线程不安全，数据紊乱。

四、线程创建（Callable）

步骤

实现Callable接口，需要返回值类型
重写Callable接口，需要抛出异常
创建实现Callable接口的目标对象
创建执行服务：

// 创建服务 Executors.newFixedThreadPool(3); 创建线程数为3个
ExecutorService executorService = Executors.newFixedThreadPool(3);

提交执行

// 提交执行任务,c1为实现Callable接口实现类的对象
Future s1 = executorService.submit(c1);

获取结果

// 获取执行线程返回结果
System.out.println(s1.get());

关闭服务

executorService.shutdownNow();

代码

package com.yang.demo02;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
public class TestCallable01 implements Callable<Boolean> {
    public TestCallable01(String url, String name) {
        this.url = url;
        this.name = name;
    }
    private String url;
    private String name;
    @Override
    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 {
        TestCallable01 c1 = new TestCallable01("https://lmg.jj20.com/up/allimg/4k/s/02/2109242332225H9-0-lp.jpg", "1.jpg");
        TestCallable01 c2 = new TestCallable01("https://lmg.jj20.com/up/allimg/tp01/1ZZQ20QJS6-0-lp.jpg","2.jpg");
        TestCallable01 c3 = new TestCallable01("https://lmg.jj20.com/up/allimg/tp04/1Z92G92I25110-0-lp.jpg","3.jpg");
        // 创建服务 Executors.newFixedThreadPool(3); 创建线程数为3个
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        // 提交执行任务
        Future<Boolean> s1 = executorService.submit(c1);
        Future<Boolean> s2 = executorService.submit(c2);
        Future<Boolean> s3 = executorService.submit(c3);
        // 获取执行线程返回结果
        System.out.println(s1.get());
        System.out.println(s2.get());
        System.out.println(s3.get());
        // 关闭服务
        executorService.shutdownNow();
    }
}
/**
 * 下载器
 */
@Slf4j
class WebDownloader {
    public void downloader(String url, String name) {
        try {
            // commons.io包 下载文件工具包
            // 通过URL下载图片
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            log.info("IO异常，downloader方法出现异常！");
        }
    }
}

五、守护线程（daemon）

线程

用户线程（main）
守护线程（gc）

虚拟机必须要确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕

如，后台记录操作日志，监控内存，垃圾回收等。

测试代码

package com.yang.state;
/**
 * @Description: 测试守护线程
 * @Author: Guo.Yang
 * @Date: 2022/02/24/23:01
 */
public class TestDaemon {
    public static void main(String[] args) {
        You you = new You();
        God god = new God();
        // 开启上帝线程
        Thread thread = new Thread(god);
        // 设置上帝线程为守护线程
        thread.setDaemon(true);
        // 开启用户线程
        thread.start();
        //开启用户线程
        new Thread(you).start();
    }
}
// 你（用户进程）
class You implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("开心的活着");
        }
        System.out.println("good bye");
    }
}
// 上帝线程（守护线程）
class God implements Runnable {
    @Override
    public void run() {
        // 正常的线程 应该为上帝线程会一直执行下去
        // 但由于是守护线程，也就是用户线程停止后，守护线程会自动结束
        while (true) {
            System.out.println("上帝守护着你");
        }
    }
}

God线程在不设置守护线程的情况下会是一直执行下去的进程
但是设置成守护线程后，用户线程执行完毕后会自动结束线程
测试截图

六、线程不安全性

1、测试List集合

测试List集合线程不安全性

众所周知List集合不安全分析下原因

测试代码

/**
 * @Description: 测试List 的线程不安全性
 * @Author: Guo.Yang
 * @Date: 2022/02/25/21:05
 */
public class TestList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}
// 输出结果：9999

预计输出情况：10000
但是在运行后，有时后出现小于 10000

原因

当两个线程同时操作list的同一个位置的时候，会覆盖掉上一个线程添加的元素

2、测试买票

测试代码

import lombok.SneakyThrows;
/**
 * @Description:
 * @Author: Guo.Yang
 * @Date: 2022/02/25/21:48
 */
public class BuyTicket{
    public static void main(String[] args) {
        A buyticket = new A();
        new Thread(buyticket, "张").start();
        new Thread(buyticket, "王").start();
        new Thread(buyticket,"李").start();
    }
}
class A implements Runnable{
    private int ticketNums = 10;
    private Boolean flag = true;
    @SneakyThrows
    @Override
    public void run() {
        while (flag) {
            buy();
        }
    }
    public void buy() throws InterruptedException {
        if(ticketNums <= 0){
            flag = false;
            return;
        }
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "拿到了"+ ticketNums--);
    }
}

结果输出

数据出现问题

// 张拿到了10
// 王拿到了9
// 李拿到了9
// 李拿到了8

解决方案

同步方法

synchronized方法

synchronized方法控制“对象”的方法，每个对象对应一把锁，每个synchronized凡法规都必须获得到该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后边被阻塞的线程才能获得这个锁，继续执行
缺陷；若将一个大的方法申明为synchronized将会影响效率

synchronized块

synchronized(obj){}
obj称之为同步监视器

Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
同步方法中无需执行同步监视器，因为同步方法的同步监视器就是this，就是对像本身，活着是class

同步监视器的执行过程

第一个线程访问，锁定同步监视器，执行其中代码
第二个线程防伪，发现同步监视器被锁定，无法访问
第一个线程访问完毕，解锁同步监视器
第二个线程访问，发现同步监视器没锁锁，然后锁定并访问

synchronized方法

测试代码

import lombok.SneakyThrows;
/**
 * @Description:
 * @Author: Guo.Yang
 * @Date: 2022/02/25/21:48
 */
public class BuyTicket{
    public static void main(String[] args) {
        A buyticket = new A();
        new Thread(buyticket, "张").start();
        new Thread(buyticket, "王").start();
        new Thread(buyticket,"李").start();
    }
}
class A implements Runnable{
    private int ticketNums = 10;
    private Boolean flag = true;
    @SneakyThrows
    @Override
    public void run() {
        while (flag) {
            buy();
        }
    }
    public void buy() throws InterruptedException {
        if(ticketNums <= 0){
            flag = false;
            return;
        }
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "拿到了"+ ticketNums--);
    }
}

* synchronized块
    * 代码块锁对象（一定要锁共享资源的变量，谁变锁谁）
    * 测试代码

/**
 * @Description: 测试List 的线程不安全性
 * @Author: Guo.Yang
 * @Date: 2022/02/25/21:05
 */
public class TestList {
    public static void main(String[] args) throws InterruptedException {
        ArrayList<String> list = new ArrayList();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
            Thread.sleep(1);
        }
        System.out.println(list.size());
    }
}

七、线程池

线程池的API：ExecutorService 和 Executors
ExecutorService：真正的线程池接口。常见的子类ThreadPoolExecutor

void execute(Runnable command); 执行任务、命令没有返回值，一般用来执行Runable
Future submit(Callable task); 执行任务，有返回值，一般用来执行Callable
void shutdown(); 关闭链接

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

多线程专题

多线程

一、线程的相关简介

二、线程的创建（Thread、Runnable）

1、方式一（继承Thread类）

2、方式二（实现Runnable）

三、初识并发问题

四、线程创建（Callable）

五、守护线程（daemon）

六、线程不安全性

1、测试List集合

2、测试买票

七、线程池

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

多线程专题

多线程

一、线程的相关简介

二、线程的创建（Thread、Runnable）

1、方式一（继承Thread类）

2、方式二（实现Runnable）

三、初识并发问题

四、线程创建（Callable）

五、守护线程（daemon）

六、线程不安全性

1、测试List集合

2、测试买票

七、线程池

热门文章

最新文章

相关电子书