2.线程实现（重点）

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量342 收藏
点赞数
分类专栏： 多线程 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52093131/article/details/122005401
版权

文章目录

线程的创建

三种创建方式

在这里插入图片描述

继承Thread类

继承Thread类实现多线程步骤如下：

  1. 自定义线程类继承Thread类
  2. 重写run() 方法，编写线程执行体
  3. 创建线程对象，调用start() 方法启动线程

创建线程方式1：继承Thread（通过查看源码发现Thread 是实现Runnable接口的）
注意：线程开启不一定立即执行，由CPU调度安排。

package com.y.demo01;

//创建线程方式一： 继承 Thread类， 重写run（）方法， 调用start（）开始线程

//总结：注意，线程开启不一定立即执行， 有CPU调度执行

public class TestThread1  extends Thread{

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

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

        TestThread1 thread1 = new TestThread1();
        thread1.start();

        for (int i = 0; i < 60; i++) {
            System.out.println("我在学习"+ i);

        }
    }
}

案例：网图下载

package com.y.demo01;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

//练习 Thread, 实现多线程同步下载图片
public class TestThread2 extends Thread{

    private String url;
    private String name;

    public  TestThread2(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) {
        TestThread2 testThread21 = new TestThread2("https://i0.hdslb.com/bfs/archive/756f7695bcdd43e45bf2313a01b9194bc637d788.jpg@640w_400h_100Q_1c.webp","1.jpg");
        TestThread2 testThread22 = new TestThread2("https://i0.hdslb.com/bfs/archive/756f7695bcdd43e45bf2313a01b9194bc637d788.jpg@640w_400h_100Q_1c.webp","2.jpg");
        TestThread2 testThread23 = new TestThread2("https://i0.hdslb.com/bfs/archive/756f7695bcdd43e45bf2313a01b9194bc637d788.jpg@640w_400h_100Q_1c.webp","3.jpg");

        testThread21.start();
        testThread22.start();
        testThread23.start();
    }
}

//下载器
class WebDownloader {
    //下载方法
    public void downloader(String url, String name){ //下载器
        try {
            //文件单元.复制URL文件
            // 把一个url变成一个文件
            FileUtils.copyURLToFile( new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

实现Runnable接口

  1. 定义MyRunnable类实现Runnable接口

  2. 实现**run()**方法，编写线程执行体

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

package com.y.demo01;


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

    public static void main(String[] args) {
        // main线程，主线程
        TestThread3 thread3 = new TestThread3();
//        Thread thread = new Thread(thread3);
//        thread.start();
        //简写
        new Thread(thread3).start();

        for (int i = 0; i < 60; i++) {
            System.out.println("我在学习"+ i);

        }
    }

}

Thread 和Runnable小结

继承Thread类
  1.子类继承Thread 类具有多线程能力
  2.启动线程：子类对象.start()
  3.不建议使用：避免OOP单继承局限性

实现Runnable 接口
  1.实现接口Runnable 具有多线程能力
  2.启动线程：传入目标对象+Thread对象.start（）
  3.推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

创建线程方式3：

实现Callable 接口

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

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

  3. 创建目标对象

  4. 创建执行服务：

  5. 提交执行：

  6. 获取结果：

  7. 关闭服务：

    package com.y.demo02;

import com.y.demo01.TestThread2;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

//线程创建方式三：实现 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() {
        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://i0.hdslb.com/bfs/archive/756f7695bcdd43e45bf2313a01b9194bc637d788.jpg@640w_400h_100Q_1c.webp","1.jpg");
        TestCallable t2 = new TestCallable("https://i0.hdslb.com/bfs/archive/756f7695bcdd43e45bf2313a01b9194bc637d788.jpg@640w_400h_100Q_1c.webp","2.jpg");
        TestCallable t3 = new TestCallable("https://i0.hdslb.com/bfs/archive/756f7695bcdd43e45bf2313a01b9194bc637d788.jpg@640w_400h_100Q_1c.webp","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();
        //关闭服务
        ser.shutdown();
    }

}


//下载器
class WebDownloader {
    //下载方法
    public void downloader(String url, String name){ //下载器
        try {
            //文件单元.复制URL文件
            // 把一个url变成一个文件
            FileUtils.copyURLToFile( new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

下载了文件名为：2.jpg
下载了文件名为：1.jpg
下载了文件名为：3.jpg

    多个线程同时操作一个对象，如：取钱、买火车票

    初识并发问题

    package com.y.demo01;

//多个线程同时操作同一个对象
//买火车票

//发现问题： 多个线程操作同一个资源的情况下， 线程不安全， 数据紊乱
public class TestThread4 implements Runnable{

    //票数 ticketNums 票券
    private int ticketNums = 10;//ticketNums 票券

    @Override
    public void run() {
        while (true) {

            if (ticketNums <= 0) {
                break;
            }
            try {
                //模拟 延迟
                Thread.sleep(200); //毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // Thread.currentThread().getName():获得当前执行线程的名字
            System.out.println(Thread.currentThread().getName() + " -->拿到了第"+ ticketNums-- +"票");

        }
    }

    public static void main(String[] args) {

        TestThread4 ticket = new TestThread4(); // 票

        //线程 线程名
        Thread thread = new Thread(ticket,"黄牛党");
        thread.start();
        // 简化
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();


    }
}
小明 -->拿到了第10票
黄牛党 -->拿到了第10票
老师 -->拿到了第9票
小明 -->拿到了第8票
黄牛党 -->拿到了第6票
老师 -->拿到了第7票
老师 -->拿到了第5票
黄牛党 -->拿到了第5票
小明 -->拿到了第5票
老师 -->拿到了第4票
黄牛党 -->拿到了第4票
小明 -->拿到了第4票
小明 -->拿到了第2票
黄牛党 -->拿到了第1票
老师 -->拿到了第3票

    案例：龟兔赛跑

    1.首先来个赛道距离，然后要离终点越来越近 ， for循环判断了100步

    2.判断比赛是否结束 ，gameOver() 方法

    3.打印出胜利者

    4.龟兔赛跑开始

    5.故事中是乌龟赢了，兔子需要睡觉，所以我们模拟兔子睡觉

    6.终于，乌龟赢了

package com.y.demo01;

//Race:比赛

// 模拟 龟兔赛跑
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 % 20 == 0) {

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            boolean flag = gameOver(i);

            //如果比赛结束了，停止程序
            if (flag){ // 默认为 true
                break;
            }
                                //线程的名字
            System.out.println(Thread.currentThread().getName()+ "跑了" +i+ "步");
        }
    }

    //判断是否完成比赛
    private  boolean gameOver (int steps){ //游戏结束
        //判断是否有胜利者
        if (winner != null){ // 已经存在胜利者了
            return true;
        }
        else if (steps >= 100) {
            winner = Thread.currentThread().getName();//线程名字 赋值给 winner
            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();
    }
}

静态代理

在这里插入图片描述

静态代理总结：

1. 真实对象和代理对象都要实现同一个接口

2. 代理对象 要代理 真实角色

好处：

代理对象 可以做很多对象做不了的事情

真实对象 专注做自己的事情

package com.y.staticProxy;

//静态代理

/*
静态代理模式总结
真实对象或目标对象 和 代理对象都要实现同一个接口
代理对象要 代理 真实角色
*/
/*
好处：
    代理对象 可以做很多 真实对象 做不了的事情
    真实对象 专注做自己的事情
 */
public class StaticProxy {

    public static void main(String[] args) {

        You you = new You();// 你要结婚

        //多线程开启
        Thread thread = new Thread( );
        thread.start();
            //简化
        new Thread().start();

         //Runnable:接口  Thread类也实现了Runnable接口
        new Thread(new Runnable() {
            @Override
            public void run() {

            }
        }).start();
        //lambda 表达式简化
        new Thread( () -> System.out.println("ai")).start();
        new Thread( ()-> System.out.println("我爱你") ).start();


        /*WeddingCompany weddingCompany = new WeddingCompany( you );
        weddingCompany.HappyMarry();*/
        //简化
        new WeddingCompany( new You()).HappyMarry();


    }

}

//共同接口  结婚
interface Marry{
    //人间四大喜事
        //久旱逢甘露
        //他乡遇故知
        //洞房花烛夜
        //金榜题名时

    void HappyMarry();

}

// 你 真实角色
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("结婚了，超开心");
    }
}

//婚庆公司 代理角色，帮助你结婚
class WeddingCompany implements Marry{

    //目标对象 结婚
//  真实对象是代理来的  代理谁 --->真实目标角色
    private Marry target;

    //构造方法：传递参数
    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {

        before();
        this.target.HappyMarry(); //这就是：真实对象 ，调用了一个结婚
        after();
    }


    //结婚之前
    private void before() {
        System.out.println("结婚之前，布置现场");
    }

    //结婚之后
    private void after() {
        System.out.println("结婚之后，收尾款");
    }


}

Lambda表达式

入 希腊字母表中排序第十一位的字母，英语名称为Lambda

避免内部类定义过多

其实质属于函数式编程概念

（params） -> expression  [表达式]
（params） -> statement [语句]
（params） -> {statement }
123
new Thread(()-> System.out.println("多线程学习")).start();
1

为什么要使用lambda 表达式

1.避免你们内部类定义过多

2.可以让你的代码看起来很简洁

3.去掉了一堆没有意义的代码，只留下核心的逻辑

函数式接口

  • 理解Functional lnterface(函数式接口）是学习Java8 lambda表达式的关键所在。

  • 函数式接口的定义

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

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

public interface Runnable{ //多线程接口
    public abstract void run();//抽象方法
}

代码实现

package com.y.lambda;

/*
推到 lambda表达式

 */
public class TestLambda1 {

    //3.静态内部类 （把 实现类 放在 静态内部类里边）
    //实现类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }


    public static void main(String[] args) {
        //创建一个接口对象
        ILike like = new Like();
        like.lambda();

         like = new Like2();
         like.lambda();

         //4.局部内部类 (方法里边)
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.lambda();

        //5.匿名内部类 , 没有类的名称，必须借助 接口 或者 父类  重写它的方法
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");

            }
        };
        like.lambda();

        //6.用 lambda简化
        like = ()-> {
            System.out.println("I like lambda5");
        };
        like.lambda();

    }


}

//1.定义一个函数式接口 （只有一个方法的接口就是函数式接口）
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}
I like lambda
I like lambda2
I like lambda3
I like lambda4
I like lambda5

简化

package com.y.lambda;

public class TestLambda2 {



    public static void main(String[] args) {

        ILove love = null;

         /*love = (int a,int b,int c) -> {
                System.out.println("i love you -->" +a);
                System.out.println("i love you -->" +b);
            };*/

        //简化1 去掉参数类型
        love=(a,b,c) ->{
            System.out.println("i love you -->" +a);
            System.out.println("i love you -->" +b);
        };
        //简化2 去掉括号 ：单个参数才可以去掉括号！
       /* love= a -> {
            System.out.println("i love you -->" +a);
        };*/
        //简化3 去掉花括号
        love = (a,b,c) -> System.out.println("i love you -->" +a);

        /**
         * 总结
         * lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，用代码块包裹
         * 前提是接口为函数式接口  函数式接口：只能有一个方法的接口是函数式接口
         * 多个参数 可以去掉参数类型，要去掉就都去掉，必须加上括号！
         */

        love.love(521,2,3);
    }

}

//定义一个函数式接口
interface ILove{
    void love(int a, int b, int c);
}


i love you -->521
小尹^_^
关注
专栏目录
六、线程的代码实现：pcb栈、线程栈、PCB初始化、中断处理函数、调度函数->多线程调度
zhangyang249的博客
11-30 3783
线程
shell中如何实现多线程
热门推荐
weixin_42973768的博客
11-10 1万+
先看一个小shell： 看执行结果： 很明显是8s ============================= 这种不占处理器却很耗时的进程，我们可以通过一种后台运行的方式 来达到节约时间的目的。看如下改进： 用“{}”将主执行程序变为一个块，用&放入后台，四次执行全部放入后台后，我们 需要用一个wait指令，等待所有后台进程执行结束， 不然 系统是不会等待的，直接继续执行后续指令，知道整个程序结束。 看结果： 可以看到，时间已经大大缩短了！ ==============.
【操作系统】实验二 处理机调度算法
sailven的博客
10-25 639
处理机调度算法实验 时间：2020-11-27
多线程详解第2讲：线程实现（重点）
林深不见鹿 的博客
04-23 6105
线程实现（重点） 1、三种创建方式 2、Thread 学习提示：查看JDK帮助文档 步骤 自定义线程类继承Thread类 重写run()方法，编写线程执行体 创建线程对象，调用start()方法启动线程 代码 package com.kaung.demo01; import java.awt.event.ItemEvent; //创建线程的方式一：继承Thread，重写run()方法，调用start开启线程 //总结 ：注意 ，线程开启不一定立即执行，由cpu调度执行 publ
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 2036
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
java多线程的实现_Java多线程实现的三种方式
weixin_30724041的博客
02-12 1776
对于所有语言来说，多线程的编程是绝不可少的。同样的Java语言也包含了多线程的开发。首先，我们先来了解一下Java语言的多线程实现方式。一、Java 多线程实现方式java中实现多线程的方式有三种，接下来我将会逐个进行介绍。1.继承Thread类继承Thread类是Java中比较常见，也是很基础的一种实现Java多线程的方式。实现的方式也比较简单，只要将需要实现多线程的Java类继承java.la...
实现多线程的几种方式
qq_49830628的博客
10-14 6585
方式一：实现继承Thread类 步骤： 1:定义一个类去继承Thread类，比如ThreadDemo 2:重写run()方法 3:在测试类中创建ThreadDemo类的对象 4:启动线程 ThreadDemo类 public class ThreadDemo extends Thread { @Override public void run() { for (int i = 0; i <100 ; i++) { System.out.print
线程的作用和实现
weixin_39399984的博客
02-07 4289
在计算机中有： 每一个运行的程序可能包括多个独立运行的线程（Thread）。 线程（Thread）是一份独立运行的程序，有自己专用的运行栈。线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。 当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。 同步这个词是从英文synchron
springboot快速实现多线程执行
wwppp987的博客
11-15 4885
首先创建一个java文件：//业务内容 } @Override public void run() {// System.out.println("开启了一个新线程");//可以按顺序运行内容，也可以直接运行内部的内容；直接运行内部内容的时候run()会优先运行 // download(file);} }然后在controller当中运行内部程序【因为需要传参】，多个请求可以在new Thread当中机型for循环执行方式为按照for循环顺序执行。
4.如何终止线程
纵横千里 捭阖四方 的专栏
08-24 4842
本文介绍了线程终止的问题 ，特别是阻塞线程的终止。主线程想让子线程停止要通过interrupt给子线程发一个信号，告诉要中断了，而不是强制将其中断。触发复位是为了让子线程保持原来的状态，是否中断则有子线程在catch中决定。如果不处理就不中断，如果要中断就是再执行一次Thread.currentThread().interrupt();
2.线程间同步和通信之信号量（静态）
08-24
总的来说，信号量在STM32 RT-thread系统中扮演着重要的角色，帮助开发者实现线程间的同步和通信。通过理解和熟练运用信号量，我们可以设计出更加高效、可靠的多线程应用程序。在实际项目中，开发者可以根据需求选择...
Java多线程实现.pdf
09-30
本篇文章将深入探讨如何利用Java 5的并发库来构建一个网络服务器模型，重点涉及线程池、阻塞队列、可重入锁以及Callable和Future接口。 首先，线程池（ThreadPool）是Java 5中引入的一个重要概念，它解决了频繁创建...
Java面试JVM+多线程重点突破.zip
03-05
多线程则是Java编程中实现并发处理的关键特性，使得程序可以同时处理多个任务。 1. **JVM内存结构**：理解JVM内存模型对于优化程序性能至关重要。主要包括堆内存（Heap）、栈内存（Stack）、方法区（Method Area）...
qtThread-2.rar qt 线程练习样例代码，继承Qobject方式
08-23
"qtThread-2.rar" 提供的是一个Qt线程练习的样例代码，主要展示了如何通过继承`QObject`来实现线程操作。 在Qt中，有两种常见的线程使用方式：一是直接使用`QThread`类，二是继承`QObject`并重载`run()`方法。本...
Linux下支持续传的多线程下载工具的设计与实现.pdf
09-07
本文主要介绍了一个基于Linux环境的下载工具的设计和实现，重点探讨了其中涉及的数据结构和技术。其中，作者李培峰和朱巧明来自苏州大学计算机工程系和东南大学计算机科学与工程系。 **设计目标：** 1. **准确性**...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 262
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 583
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 563
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 455
spring boot 整合 mybatis
Java多线程面试重点解析
2. 实现Runnable接口：创建一个新的类实现Runnable接口，实现run()方法。然后将这个Runnable对象作为参数传递给Thread类的构造函数，创建Thread对象并调用start()方法启动线程。 线程的并发执行有多种调度策略，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小尹^_^

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值