Java多线程随笔（1）：线程的实现

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量575 收藏
点赞数
文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AVOP_210/article/details/108785389
版权
本文介绍了Java中进程和线程的基本概念，并详细阐述了线程创建的三种方式：继承Thread类、实现Runnable接口以及实现Callable接口。针对Thread类，探讨了使用lambda表达式简化线程创建以及静态代理模式在线程中的应用。
摘要由CSDN通过智能技术生成

目录

进程和线程的基本概念

线程创建的三种方式

1. 继承Thread类

2. 实现Runnable接口

3. 实现Callable接口（）

探究Thread类

1. lambda 表达式

2. 静态代理模式

进程和线程的基本概念

 

进程是程序执行和资源分配的基本单位，线程是CPU调度和执行的基本单位；

 

线程创建的三种方式

 

1. 继承Thread类

关于Thread类：Thread类继承Object类，同时实现了Runnable接口。

实现方法：①声明一个类，继承Thread类，②重写run()方法，③创建线程对象，调用start()方法。

不建议使用：OOP单继承局限性。

public class TestThread1 extends Thread {
    @Override
    public void run() {
        //重写run()方法
    }

    public static void main(String[] args){
        TestThread1 t = new TestThread1();
        t.start();
    }
}

举例：网图下载

package demo.thread;

import org.apache.commons.io.FileUtils;

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

public class TestThread1 extends Thread {
    private String url;
    private String fileName;

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

    //执行主体
    @Override
    public void run() {
        //重写run()方法
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, fileName);
        System.out.println(fileName+"已经下载完成");
    }

    public static void main(String[] args){
        TestThread1 t1 = new TestThread1("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1600972938327&di=d93212c74560e6ecb7d766a1452a2a87&imgtype=0&src=http%3A%2F%2Fimage.namedq.com%2Fuploads%2F20190511%2F19%2F1557575056-oBLizxVyGb.jpg", "1.jpg");
        TestThread1 t2 = new TestThread1("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1600973064432&di=bdb1cfcf3b886920ddfbfe2329287f59&imgtype=0&src=http%3A%2F%2Fn.sinaimg.cn%2Fsinacn18%2F217%2Fw640h377%2F20181112%2F81e4-hnstwwr1625807.jpg", "2.jpg");
        TestThread1 t3 = new TestThread1("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1600973064432&di=6f9d342fd1e57de39db03f283299ffc6&imgtype=0&src=http%3A%2F%2Fc-ssl.duitang.com%2Fuploads%2Fitem%2F201906%2F25%2F20190625105243_xwgss.thumb.400_0.jpg", "3.jpg");

        t1.start();
        t2.start();
        t3.start();
    }
}

//下载器类
class WebDownloader{
    public void downloader(String url, String fileName){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(fileName));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("dowloader() Exception");
        }
    }
}

 

2. 实现Runnable接口

实现方法：①声明一个类，实现Runnable接口，②重写run()方法，③创建实现类对象，创建代理类对象，调用start()方法。

建议使用：避免单线程的局限性，方便同一个对象被多个线程使用。

public class TestThread2 implements Runnable{
    @Override
    public void run() {
        //重写run方法
    }
    public static void main(String[] args){
        TestThread2 t2 = new TestThread2();
        Thread t = new Thread(t2);
        t.start();
    }
}

举例：模拟龟兔赛跑

public class Race implements Runnable {

    private static String winner;

    @Override
    public void run() {

        for (int i = 0; i <= 1000; i++) {
            boolean flag = gameOver(i);
            if(flag){
                break;
            }
            if(i%100 == 0){
                System.out.println(Thread.currentThread().getName()+"已经跑了"+i+"米");
            }
            if(i == 500 && Thread.currentThread().getName().equals("兔子")){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    boolean gameOver(int distance){
        if(winner != null)
            return true;
        else {
            if(distance>=1000){
                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();
    }
}

 

3. 实现Callable接口（）

实现方法：①声明一个类，实现Callable接口，②重写call方法，③主线程创建执行服务，④提交执行，⑤获取call方法的返回值，⑥关闭服务 

优点：①可以定义返回值，②可以抛出异常

import java.util.concurrent.*;

public class TestCallable implements Callable {
    @Override
    public Object call() throws Exception {
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable testCallable = new TestCallable();
        //创建执行任务
        ExecutorService service = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> result1 = service.submit(testCallable);
        //获取结果
        boolean r1 = result1.get();
        //关闭服务
        service.shutdownNow();
    }
}

 

探究Thread类

 

1. lambda 表达式

优势：

  •  避免匿名内部类定义过多
  • 可以让代码更简洁
  • 去掉没有意义的代码，只留下核心逻辑

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

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

Runnable接口只有符合函数式接口，因此可以在实现Runnable接口时直接使用Lambda表达式。 

 各种接口实现举例：

public class Lambda {

    //3.静态内部类
    static class Work2 implements Person{
        @Override
        public void career(String str) {
            System.out.println(str);
        }
    }

    public static void main(String[] args) {

        //4.局部内部类
        class Work3 implements Person{
            @Override
            public void career(String str) {
                System.out.println(str);
            }
        }

        //5.匿名内部类
        Person person4 = new Person() {
            @Override
            public void career(String str) {
                System.out.println(str);
            }
        };

        //6.Lambda表达式
        Person person5 = (str)->{
            System.out.println(str);
        };

        Person person1 = new Work1();
        Person person2 = new Work2();
        Person person3 = new Work3();

        person1.career("student");
        person2.career("doctor");
        person3.career("teacher");
        person4.career("professor");
        person5.career("officer");


    }
}

//1.定义函数接口
interface Person{
    void career(String str);
}

//2.类
class Work1 implements Person{
    @Override
    public void career(String str) {
        System.out.println(str);
    }
}

 

2. 静态代理模式

要求：真实对象和代理对象都需要实现同一个接口，代理对象要代理真实对象。

好处：代理对象可以做很多真实对象做不了的事情，真实对象专注做自己的事情。

以婚庆公司举例：

public class StaticProxy {

    public static void main(String[] args) {

        You you = new You();

        new WeddingCompany(you).happyMarry();
    }

}

interface Marry{
    void happyMarry();
}

class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("happy marry");
    }
}

class WeddingCompany implements Marry{

    private You target;

    public WeddingCompany(You target){
        this.target = target;
    }

    @Override
    public void happyMarry() {

        before();
        this.target.happyMarry();
        after();
    }

    public void  before(){
        System.out.println("布置婚礼");
    }

    public void after() {
        System.out.println("收尾款");
    }
}

在Java中线程的设计就使用了静态代理设计模式，其中自定义线程类实现Runable接口，Thread类也实现了Runalbe接口，在创建子线程的时候，传入了自定义线程类的引用，再通过调用start()方法，调用自定义线程对象的run()方法。实现了线程的并发执行。

AVOP_210
关注
四个算法排序 1.选择排序 2.冒泡排序 3.插入排序 4.希尔排序
m0_49524888的博客
08-09 274
1.选择排序 算法描述: n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下： 初始状态：无序区为R[1..n]，有序区为空； 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区； n-1趟结束，数组有序化了。 static vo
回溯算法经典案例 1 ——N皇后 Java
AVOP_210的博客
09-14 2181
问题分析 N 皇后问题研究的是如何将 N 个皇后放置在 N×N 的棋盘上，并且使皇后彼此之间不能相互攻击。 皇后的走法是：可以横直斜走，格数不限。因此要求皇后彼此之间不能相互攻击，等价于要求任何两个皇后都不能在同一行、同一列以及同一条斜线上。 直观的做法是暴力枚举将 N 个皇后放置在 N×N 的棋盘上的所有可能的情况，并对每一种情况判断是否满足皇后彼此之间不相互攻击。暴力枚举的时间复杂度是非常高的，因此必须利用限制条件加以优化。 显然，每个皇后必须位于不同行和不同列，因此将 N个皇后放置在 N×N
多线程——锁private final ReentrantLock lock = new ReentrantLock()；
beishanqiye的博客
09-21 1302
package thread; import java.util.concurrent.locks.ReentrantLock; public class TestLock { public static void main(String[] args) { Lock1 lock = new Lock1(); new Thread(lock,"张").start(); new Thread(lock,"李").start(); .
上海中国电信IPTV频道列表
zhangxy0605的博客
06-15 2万+
本数据采于2017年6月， 频道号 频道名 频道号 频道名 频道号 频道名 1 新闻综合 123 东方购物-5HD 325 CCTV-高网 2 东方卫视 124 3
sqlmap --tamper 绕过WAF脚本分类整理
热门推荐
whatday的专栏
01-29 5万+
支持的数据库 编号 脚本名称 作用 实现方式 all 1 apostrophemask.py 用utf8代替引号 ("1 AND '1'='1")  '1 AND %EF%BC%871%EF%BC%87=%EF%BC%871'  2 base64encode.py  用base64编码替换 ("1' A
Java多线程随笔（3）：线程同步
AVOP_210的博客
09-29 799
线程同步 多个线程访问同一个对象，并且某些线程还想修改这个对象，这个时候就需要线程同步； 线程同步就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池，形成队列，等待前面线程使用完毕，下一个线程再使用； 形成条件：队列+锁（synchronized） 不安全案例 ...
Java多线程随笔（4）：线程通信
AVOP_210的博客
10-06 472
生产者消费者问题 生产者消费者问题是在一个系统中，存在生产者和消费者两种角色，他们通过内存缓冲区进行通信，生产者生产消费者需要的资料，消费者把资料做成产品。synchronized只能实现线程同步，无法实现线程通信。 Java的Object基类就提供了几个方法解决线程通信问题： 注意：只能在同步方法或者同步块中使用 解决方法 1. 管程法 ...
Java多线程随笔（2）：线程状态
AVOP_210的博客
09-27 574
探究Thread类 1. lambda 表达式 优势： 避免匿名内部类定义过多 可以让代码更简洁 去掉没有意义的代码，只留下核心逻辑 函数式接口：任何接口，如果只包含一个抽象方法，那么他就是一个函数式接口。 对于函数式接口，我们可以通过lambda表达式来创建接口的对象。 Runnable接口只有符合函数式接口，因此可以在实现Runnable接口时直接使用Lambda表达式。 各种接口实现举例： public class Lambda { //3.静态内部类 ...
java多线程相关
03-30
本篇将深入探讨Java多线程的相关知识，结合《java随笔杂记.doc》文档中的内容，我们将覆盖以下几个方面： 1. **线程的创建方式** - 实现`Runnable`接口：创建一个实现了`Runnable`接口的类，然后将其实例传递给`...
【Java多线程】volatile关键字【随笔，持续更新】
阿磊的博客
04-14 307
volatile关键字volatile关键字的两大作用1.保证内存、线程间可见2.禁止指令重排序 volatile关键字的两大作用 1.保证内存、线程间可见 面试题： 实现一个容器，提供两个方法，add、size。 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数数到5个时，线程2给出提示并结束 public class TestOne { //volatile保...
Java面试笔记：Java线程安全的集合类有哪些？线程不安全的集合类有哪些？ArrayList为什么会发生并发修改异常?
蓝多多的小仓库
11-10 1436
Java面试笔记：Java线程安全的集合类有哪些？线程不安全的集合类有哪些？ArrayList为什么会发生并发修改异常?
【Java多线程】JUC之线程池(二)再次邂逅线程池ThreadPoolExecutor的原理
墩墩分墩
08-23 258
**一个线程池包括以下四个基本组成部分：** 1. 线程工厂（ThreadFactory）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务； 2. 工作线程（Worker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务； 3. 任务接口（Runnable）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等； 4. 任务队列（workQueue）：用于存放待执行的任务。提供一种缓冲机制。
Java创建线程的两种常用方法简介（随笔）
gaofengyan的博客
01-15 2886
1.通过继承Thread（线程）类本身。         创建线程时继承Thread类并重写Thread类的run（）方法。Thread类的run（）是线程要执行操作任务的方法，所以线程要执行的操作代码都需要写在run（）方法中，并通过调用start（）方法来启动线程。                   使用Thread类创建线程的优点是简单明了；同时最大的缺点是：如果定义的类已经继承了其...
2016年终总结与来年计划
weixin_30629653的博客
12-31 2万+
　　光阴似箭，日月如梭！眨眼间已到年底，今年感慨颇丰，获益良多。因为我认为努力了就肯定会有收获，哪怕是收获那一滴滴辛勤的汗水。 　　我在公司任务轻松时，加了些前端群（重点推荐豪情群），在群里分享技术以及生活的点滴，同时认识了一些志同道合的朋友。有大牛建议我体验一番分享的乐趣，于是我下下半年开始写博。虽质量不高，但其中的乐趣博友们应该都能感受到。写完每篇博文后，我都能体会到了在这个浮躁的时代我平静...
Java-网络
2301_81543552的博客
09-14 784
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java企业面试题3
最新发布
m0_74972727的博客
09-15 773
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 798
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
自动生成不重复的订单id
ClaireCheney的博客
09-13 345
【代码】自动生成不重复的订单id。
Java多线程程序设计：理解与实现
"Java多线程程序设计-JSP教程,Java技巧及代码" 在Java编程中，多线程是一项核心技能，特别是在开发服务器端应用程序时，如JSP（Java Server Pages）应用。Java多线程允许程序员在一个程序中同时运行多个执行路径，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值