多线程详解第2讲：线程实现（重点）

最新推荐文章于 2024-03-29 15:18:56 发布
最新推荐文章于 2024-03-29 15:18:56 发布
阅读量5.7k 收藏
点赞数 1
分类专栏： JUC并发 文章标签： java 多线程 线程实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45629285/article/details/116034464
版权

线程实现（重点）

目录

1、三种创建方式

在这里插入图片描述

2、Thread

学习提示：查看JDK帮助文档

步骤

  1. 自定义线程类继承Thread类

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

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

代码

package com.kaung.demo01;

import java.awt.event.ItemEvent;

//创建线程的方式一：继承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 testThread1 = new TestThread1();

        //调用start()方法开启线程,执行run方法
        testThread1.start();
        for(int i = 0; i < 20; i++){
            System.out.println("我在学习多线程---"+i);
        }
    }
}

执行结果
在这里插入图片描述
主线程和run方法线程交替执行。

3、案例：下载图片

代码

package com.kaung.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 t1 = new TestThread2("https://public-cdn-oss.mosoteach.cn/books/mobile/cover-1@2x.jpg","1.jpg");
        TestThread2 t2 = new TestThread2("https://public-cdn-oss.mosoteach.cn/books/mobile/cover-1@2x.jpg","2.jpg");
        TestThread2 t3 = new TestThread2("https://public-cdn-oss.mosoteach.cn/books/mobile/cover-1@2x.jpg","3.jpg");
        //先下载t1
        t1.start();
        //然后t1
        t2.start();
        //最后t3
        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方法出现异常");
        }
    }

}

运行截图

在这里插入图片描述
我们开启了三个线程，这三个线程并不是按序执行的，谁先抢夺到了时间，谁先执行。

验证了结论：在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预的。

4、实现Runnable接口

步骤

  1. 定义MyRunnable类实现Runnable接口

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

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

代码

package com.kaung.demo01;

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) {

        //创建runable接口的实现类对象
        TestThread3 testThread3 = new TestThread3();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(testThread3);
        thread.start();

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

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

5、小结

继承Thread类

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

实现Runable接口

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

6、初始并发问题

代码

package com.kaung.demo01;
//多个线程同时操作一个对象
//买火车票的例子

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

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

        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛党").start();
    }
}

运行截图
在这里插入图片描述
发现问题 ： 多个线程操作同一个资源的情况下，线程不安全，数据紊乱。

7、龟兔赛跑

在这里插入图片描述
代码模拟

package com.kaung.demo01;

//模拟龟兔赛跑
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(10);
                } 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 is "+winner);
            return true;
        }
        return false;
    }

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

8、实现Callable接口（了解即可）

在这里插入图片描述

9、静态代理

在这里插入图片描述
模式总结

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

好处

  • 代理对象可以做很多真实对象做不了的事情
  • 真实对象专注做自己的事情

代码

import sun.plugin2.main.client.WDonatePrivilege;

//静态代理模式总结
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实对象

//好处
    //代理对象可以做很多真实对象做不了的事情
    //真实对象专注做自己的事情
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();

        new Thread(()-> System.out.println("我爱你")).start();

        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() {
        brfore();
        this.target.HappyMarry(); //这就是真实对象
        after();
    }

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

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

10、Lamda表达式

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

  • 避免匿名内部类定义过多

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

new Thread（()->System.out.println(“多线程学习。。。。”)）.start()

在这里插入图片描述
为什么要使用lambda表达式

  • 避免匿名内部类定义过多
  • 可以让你的代码看起来很简洁
  • 去掉了一堆没有意义的代码，只留下核心的逻辑。

也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多了，看习惯了，就好了

理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在

函数式接口的定义：

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

代码推导lambda表达式

package com.kuang.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");
    }
}

代码2

package com.kuang.lambda;

public class TestLambda2 {
    public static void main(String[] args) {

        ILove love = (int a)->{
            System.out.println("I love you-->"+a);
        };
        love.love(520);

        //简化1 参数类型
        love = (a)->{
            System.out.println("I love you-->"+a);
        };
        love.love(521);

        //简化2 简化括号
        love = a->{
            System.out.println("I love you-->"+a);
        };
        love.love(522);

        //简化2 简化花括号
        love = a->System.out.println("I love you-->"+a);;
        love.love(523);
    }
}
//函数式接口
interface ILove{
    void love(int a);
}

总结

  • lambda表达式只能在有一行代码的情况下才能简化成一行，如果有多行，那么就用代码块包裹。
  • 前提是接口为函数式接口 。
  • 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号。

多线程详解系列文章目录

多线程详解第1讲：线程简介

多线程详解第2讲：线程实现（重点）

多线程详解第3讲：线程状态

多线程详解第4讲：线程同步（重点）

多线程详解第5讲：线程协作

林小鹿@
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
多线程（二）线程的调度
chansr的博客
10-11 2017
线程的调度 在单CPU的计算机中，一个时刻只有一个线程运行。所谓多线程并行 工作，即在微观上，各个线程在极小 的时间段内，轮流获得CPU资源的使用权。在宏观 上，则表现为多个线程同时执行。即使在多CPU的计算机中，线程数量超过CPU数量时，处于运行状态的多个线程，依然需要排队等待CPU资源。 在Java中，可以通过以下4种方法，来为多个线程分配CPU的使用权： 设置优先级（Priority） 休...
多线程详解——中（线程状态、线程同步）
nswdiphone6的博客
02-04 223
3.线程状态 线程方法： setPriority(int newPriority) 更改线程的优先级。 static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程体休眠。 void join()等待改线程终止 static void yield() 暂停当前正在执行的线程对象，并执行其他线程 void interrupt() 中断线程 （不建议使用） boolean isAlive() 测试线程是否处于活动状态 停止线程： 不推荐使用JDK提供的stop()、
创建线程的第三种方式：实现Callable接口（含部分源码解析）
just_still_away的博客
04-05 2420
创建线程的第三种方式——实现Callable接口 package com.lqy.Multithreading;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/*创建线程的第三种方法：实现Callable接口实现Callable接口是创建线程的三种方法中唯一一个带有返回值的方法步骤：1、实现Callable接
Java多线程-线程池ThreadPoolExecutor的submit返回值Future
花飘万家雪
11-06 6635
一般使用线程池执行任务都是调用的execute方法，这个方法定义在Executor接口中： public interface Executor { void execute(Runnable command); } 1 2 3 这个方法是没有返回值的，而且只接受Runnable。 那么像得到线程的返回值怎嘛办呢？ 在ExecutorService接口中能找到这个方法： <T> Future<T> submit(Callable<T> task);
Java线程 (使用Callable实现多线程)，看完你发现多线程多么简单！
最新发布
bq520111的博客
03-29 632
还有更多的Redis、MySQL、JVM、Kafka、微服务、Spring全家桶等学习笔记这里就不一一列举出来。
使用callable方式创建线程
qq_41206954的博客
07-12 1316
记录平常一些小事
使用Callable接口创建线程
我的博客
09-18 1772
创建线程的方法 一种是通过创建Thread类，另一种是通过使用Runnable创建线程。但是，Runnable缺少的一项功能是，当线程终止时（即run（）完成时），我们无法使线程返回结果。为了支持此功能，Java中提供了Callable接口。 当然了还可以使用线程池创建线程。 Callable接口和Runnable接口的区别 Callable接口中定义了需要有返回的任务需要实现的call方法。 比如主线程让一个子线程去执行任务，子线程可能比较耗时，启动子线程开始执行任务后， 主线程就去做其他事情了，过了一会
Java用Callable接口创建线程
tanxinji的博客
04-20 5049
 一、概述  使用Callable接口创建线程能够返回数据。与Runnable接口创建线程的方式有点类似，也是需要通过Thread类来创建线程。由于Thread类的构造函数中没有Callable接口，选用了FutureTask类来作为连接创建线程。  FutureTask类实现了RunnableFuture接口，而RunnableFuture接口继承了Runnable, Future接口。在FutureTask类中构造函数可以传入Callable对象，以此建立关系。  通过FutureTask中的get()
基于C#实现的轻量级多线程队列图文详解
12-25
第二种方式，使用线程池或者Task我们虽然可以通过设置线程池的最大线程数量来限制线程最大数，但是这个设置由于是全局的，就会造成所有使用线程池或Task的地方都会受到此设置的限制。 当然，第二种方式肯定是优
Java多线程继承Thread类详解第1/2页
09-02
Java提供了两种主要的多线程实现方式：继承`Thread`类和实现`Runnable`接口。本文将详细讲解继承`Thread`类来创建和管理线程的方法。 首先，创建一个新线程的基本步骤是定义一个新的类，该类继承自`Thread`类。在这...
利用curl 多线程 模拟 并发的详解
12-19
首先，先了解下 php中的curl多线程函数：复制代码 代码如下:# curl_multi_add_handle# curl_multi_close# curl_multi_exec# curl_multi_getcontent# curl_...步骤总结如下：第一步：调用curl_multi_init第二步：循环调
Java 多线程实例详解（三）
09-01
在Java多线程编程中，线程安全是一个至关重要的概念，尤其在并发处理共享资源时。上述例子展示了线程安全问题的一个典型实例，即银行账户取款操作。在这个例子中，两个线程（代表你和你的配偶）同时尝试从同一个账户...
Java多线程之中断线程(Interrupt)的使用详解
09-05
Java中的多线程允许并发执行多个任务，而中断机制是Java提供的一种优雅地停止线程执行的方式。`Thread.interrupt()`方法是中断线程的主要手段，但它的行为并不像字面意义上那样直接终止线程。相反，它通过设置线程的...
Callable实现线程
weixin_53126056的博客
12-09 175
实现线程的第三种方式 实现Callable接口 public class ThreadTest07 { public static void main(String[] args) throws Exception { FutureTask task =new FutureTask(new Callable() { @Override public Object call() throws Exception { //call方法
java 实现Callable 多线程
longum的博客
08-22 2431
Java多线程，实现Callable 多线程完成处理List分段数据
通过Callable实现多线程
kongshuchen的博客
06-04 3440
在java.util.concurrent包下，相比较于通过实现Runnable接口的run方法来实现多线程，优点在于可以有返回值，可以抛出异常，因为run方法是void的，并且不能抛出异常，但是Callable的方式缺点在于较为繁琐。 Callable的任务执行后可返回值，运行Callable任务可以拿到一个Future对象。Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待
使用Callable实现线程异步执行
lq_bog的博客
03-08 586
使用Callable实现线程异步执行
秒杀多线程1
08-08
在第二题中，我们讨论了线程与进程的区别。线程是进程中的执行单元，一个进程可以包含多个线程，它们共享进程的资源和地址空间。而进程是一个独立的执行环境，拥有自己的地址空间和资源。线程之间的切换比进程之间的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

林小鹿@

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

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

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

打赏作者

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

抵扣说明：

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

余额充值