多线程详解

最新推荐文章于 2021-07-19 20:05:37 发布

度心℃

最新推荐文章于 2021-07-19 20:05:37 发布

阅读量674

点赞数 2

分类专栏： Java基础

本文链接：https://blog.csdn.net/James____Gosling/article/details/117133273

版权

本文深入探讨了多线程的核心知识点，包括线程的创建方法（如继承Thread类、实现Runnable接口和Callable接口），线程的状态、方法（如线程同步、线程礼让、join、线程优先级等）以及并发控制。通过实例分析，如买火车票、龟兔赛跑和静态代理模式，展示了线程在实际场景中的应用。此外，文章还提到了Lambda表达式在简化多线程代码中的作用以及线程同步的多种策略，如同步方法和同步块，以及死锁和Lock的使用，帮助读者理解如何避免和解决多线程中的问题。

摘要由CSDN通过智能技术生成

核心知识点介绍：

**进程：**再操作系统中运行的程序就是进程，比如你的QQ，播放器，游戏等等……
线程：一个进程中可以有多个线程，如播放视频时听声音，看图像，看弹幕等等……
程序：程序是指指令和数据的有序集合，其本身没有任何动作的含义，是一个静态的概念。
而进程则是执行程序的一次执行过程，他是一个动态的概念。是系统资源分配的单位
通常在一个进程中可以包含多个线程，当然一个进程中至少要有一个线程，不然没有存在的意义。线程时CPU资源调度和执行的单位。
核心要点：
1、线程就是独立的执行路径
2、在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
3、main()称之为主线程，为系统的入口，用于执行整个程序。
4、在一个进程中，如果开辟了多个线程，线程的运行有调度器（CPU）安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预。
5、对同一份资源操作时，会存在资源抢夺问题，需要加入并发控制。
6、线程会带来额外的开销，如CUP调度，并非控制开销。
7、每个线程在自己的工作内存交互，内存控制不当会造成数据不一致。

线程创建方法

！Thread类 ----->继承Thread
！Runable接口------->实现Runnable接口
！Callable接口--------> 实现Callable接口

1、继承Thread类

步骤：
1、自定义线程类继承Thread类
2、重写rnn()方法，编写线程执行体
3、创建线程对象，调用start()方法启动线程
两条线程时同时执行的，案例如下：

public class TestThread extends Thread{
   
    @Override
    public void run() {
   
        //run方法线程体
        for (int i =0;i<1000;i++){
   
            System.out.println("我在看代码"+i);
        }
    }

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

        //创建一个线程对象，
        TestThread testThread = new TestThread();
        //调用start方法，开启线程
        testThread.start();


        for (int i =0 ;i<1000;i++){
   
            System.out.println("我在睡大觉"+i);
        }
    }
}

在这里插入图片描述
总结：
1、线程开启不一定立即执行，线程的运行是由CPU调度的，所以每次运行的结果都是不一样的。
2、结果是线程交替执行的。
练习：下载图片

public class TestThread1 extends Thread{
   

    private String url; //网络图片地址
    private String name; //保存的文件名

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

    //下载图片的执行体
    @Override
    public void run() {
   
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名："+name);
    }

    public static void main(String[] args) {
   
        TestThread1 testThread1 =new TestThread1("https://img-blog.csdnimg.cn/20210521155645451.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk4NjcxMw==,size_16,color_FFFFFF,t_70","tupian1");
        TestThread1 testThread2 =new TestThread1("https://img-blog.csdnimg.cn/20210521155645451.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk4NjcxMw==,size_16,color_FFFFFF,t_70","tupian2");
        TestThread1 testThread3 =new TestThread1("https://img-blog.csdnimg.cn/20210521155645451.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk4NjcxMw==,size_16,color_FFFFFF,t_70","tupian3");
        //先下载tupian1
        testThread1.start();
        //先下载tupian2
        testThread2.start();
        //先下载tupian3
        testThread3.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、实现runnable接口

//创建线程方式2：实现runnable方法，重写run方法,执行线程需要对如runnable接口实现类，调用start方法
public class TestThread2 implements Runnable{
   
    @Override
    public void run() {
   
        //run方法线程体
        for (int i =0;i<1000;i++){
   
            System.out.println("我在看代码"+i);
        }
    }

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

        //创建一个runnable接口的实现类对象，
        TestThread2 testThread2 = new TestThread2();
        //创建线程对象，通过线程对象来开启我们的线程
        Thread thread = new Thread(testThread2);
        thread.start();



        for (int i =0 ;i<1000;i++){
   
            System.out.println("我在睡大觉"+i);
        }
    }
}

总结（实现Runnable接口其实就是代理模式）：
1、创建一个类实现Runnable接口
2、重写run方法，run方法里面就是你要运行的代码块
3、创建Thread类，把你实现Runnable接口的类传给Thread
4、调用Thread对象的start方法完成启动线程

练习：买火车票

**Thread.currentThread().getName()：**此方法可以拿到自己线程的名称
**Thread.sleep：**可以让线程延时，单位是毫秒

/**
 * 多个线程同时操作同一个对象
 * 买火车票的例子
 * 发现问题：
 *   多个线程操作同一个资源的情况下，线程不安全，数据紊乱。
 */
public class TestThread3 implements Runnable{
   
    //票数
    private int ticks=10;
    @Override
    public void run() {
   
     while (true){
   
         if (ticks<=0){
   
             break;
         }
         //模拟延时
         try {
   
             Thread.sleep(200);
         } catch (InterruptedException e) {
   
             e.printStackTrace();
         }
         System.out.println(Thread.currentThread().getName()+"拿到了"+ticks--+"票");
     }
    }

    public static void main(String[] args) {
   
        TestThread3 testThread3 = new TestThread3();
        //三个线程
        new Thread(testThread3,"唐康").start();
        new Thread(testThread3,"曲波").start();
        new Thread(testThread3,"赵童").start();
        new Thread(testThread3,"黄牛").start();
    }
}

龟兔赛跑案例：

/**
 * 模拟龟兔赛跑
 */
public class Race implements Runnable{
   
    //冠军
    private static String winner;
    @Override
    public void run() {
   
        for (int i = 0; i <= 100; i++) {
   

            //模拟兔子休息
            if (Thread.currentThread().getName().equals("兔子") && i%10 == 0){
   
                try {
   
                    Thread.sleep(200);
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag=gameOver(i);
            if (flag){
   
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }
    }

    //判断是否完成比赛
    private boolean gameOver(int steps){
   
        //判断是否有胜利者
        if (winner!= null){
   //已经存在胜利者了
            return true;
        }{
   
            if (steps >= 100){
   
                winner = Thread.currentThread().getName();
                System.out.println("winner是"+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
   
        Race race = new Race();
        new Thread(race,"兔子").start();
        new Thread(race,"乌龟").start();

    }
}

总结：
1、Thread.currentThread().getName()：返回该线程的名字
1、Thread.sleep(200)：线程睡眠

3、实现Callable接口

步骤：
1、实现Callable接口，需要返回值类型；
2、重写call方法，需要抛出异常
3、创建目标对象
4、创建执行服务:ExecutorService ser = Executors.newFixedThreaPoo1(1);
5、提交执行：Future result1 = ser.submit(t1);
6、获取结果:boolean r1 = result1.get
7、关闭服务：ser.shutdownNow();

/**
 * 线程创建方式三：实现Callable接口
 */
public class TestCallable implements Callable<Boolean> {
   
    private String url; //网络图片地址
    private String name; //保存的文件名
    public TestCallable(String url,String name){

最低0.47元/天解锁文章

度心℃

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
2
评论
多线程详解

核心知识点介绍：**进程：**再操作系统中运行的程序就是进程，比如你的QQ，播放器，游戏等等……线程：一个进程中可以有多个线程，如播放视频时听声音，看图像，看弹幕等等……程序：程序是指指令和数据的有序集合，其本身没有任何动作的含义，是一个静态的概念。而进程则是执行程序的一次执行过程，他是一个动态的概念。是系统资源分配的单位通常在一个进程中可以包含多个线程，当然一个进程中至少要有一个线程，不然没有存在的意义。线程时CPU资源调度和执行的单位。核心要点：1、线程就是独立的执行路径2、在程序运行时
复制链接

扫一扫

专栏目录