多线程的三种建立方式

最新推荐文章于 2023-04-13 20:44:12 发布
最新推荐文章于 2023-04-13 20:44:12 发布
阅读量233 收藏
点赞数
分类专栏： 【Java进阶】 文章标签： 多线程

public class Thread extends Object implements Runnable

  1. 定义Thread类的子类，并重写其run()方法
  2. 创建Thread子类的实例，即创建了线程对象
  3. 调用线程对象的start()方法启动线程
public class FirstThread extends Thread {
    public void run(){
        for(int i=0;i<100;i++){
            /*
             * Thread类已经继承了Object
             * Object类创建了name选项 并且有其getName(),setName()方法
             * 在继承Thread的类里面使用时只需要用this引用
            */
            System.out.println(this.getName()+" "+i);
        }
    }

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i==20){
                new FirstThread().start();
                new FirstThread().start();
            }
        }
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

Thread类已经继承了Object 
Object类创建了name选项 并且有其getName(),setName()方法 
在继承Thread的类里面使用时只需要用this引用

上面两个副线程和主线程随机切换，又因为使用的是继承Thread的类所以两个副线程不能共享资源

start()方法调用后并不是立即执行多线程代码，而是使得该线程编程可运行状态,什么时候运行是由操作系统决定的

实现Runnable接口创建线程类

public Thread() 
public Thread(Runnable target) 
public Thread(Runnable target,String name)

  1. 定义Runnable接口的实现类，并重写该接口的run()方法
  2. 创建Runnable实现类的实例，并以此作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
public class SecondThread implements Runnable {
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }

    public static void main(String[] args) {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);

            if(i==20){
                SecondThread st=new SecondThread();
                //通过new Thread(target,name)创建线程
                new Thread(st,"新线程1").start();
                new Thread(st,"新线程2").start();
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

上面的结果是两个副线程和主线程随机切换，但是并没有共享资源，因为他们根本没有能用来共享的资源。

start()方法调用后并不是立即执行多线程代码，而是使得该线程编程可运行状态,什么时候运行是由操作系统决定的

继承Thread类和创建Runnable接口的共享资源详解

在只有可以用来共享的资源时候，也就是同用一个实例化对象。两个创建方式在共享资源时才会有所区别，否则它们都不会共享资源共享资源通常用private static 修饰符来修饰。

class Thread1 extends Thread{  
    private int count=5;  
    private String name;  
    public Thread1(String name) {  
       this.name=name;  
    }  
    public void run() {  
        for (int i = 0; i < 5; i++) {  
            System.out.println(name + "运行  count= " + count--);  
            try {  
                sleep((int) Math.random() * 10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  

    }  
}  

public class Main {  

    public static void main(String[] args) {  
        Thread1 mTh1=new Thread1("A");  
        Thread1 mTh2=new Thread1("B");  
        mTh1.start();  
        mTh2.start();  

    }  

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

B运行 count= 5 
A运行 count= 5 
B运行 count= 4 
B运行 count= 3 
B运行 count= 2 
B运行 count= 1 
A运行 count= 4 
A运行 count= 3 
A运行 count= 2 
A运行 count= 1

正是因为有了private int count=5;一句才有了共享资源，但这是继承Thread类的子类，并不能共享资源

class Thread2 implements Runnable{  
    private int count=15;  
    public void run() {  
          for (int i = 0; i < 5; i++) {  
              System.out.println(Thread.currentThread().getName() + "运行  count= " + count--);  
                try {  
                    Thread.sleep((int) Math.random() * 10);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            }  

    }  

}  
public class Main {  

    public static void main(String[] args) {  

        Thread2 my = new Thread2();  
            new Thread(my, "C").start();//同一个mt，但是在Thread中就不可以，如果用同一个实例化对象mt，就会出现异常     
            new Thread(my, "D").start();  
            new Thread(my, "E").start();  
    }  

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

C运行 count= 15 
D运行 count= 14 
E运行 count= 13 
D运行 count= 12 
D运行 count= 10 
D运行 count= 9 
D运行 count= 8 
C运行 count= 11 
E运行 count= 12 
C运行 count= 7 
E运行 count= 6 
C运行 count= 5 
E运行 count= 4 
C运行 count= 3 
E运行 count= 2

同样的正是因为有了private int count=15这个共同的实例化对象，实现Runnable的类才可以共享资源

那么为什么继承Thread类的子类实现Runable接口的类在共享资源时有区别呢？ 
因为Java中只能支持单继承，单继承特点意味着只能有一个子类去继承 
而Runnabl接口后可以跟好多类，便可以进行多个线程共享一个资源的操作

使用Callable和Future创建线程

Callable怎么看起来都像Runnable接口的增强版，Callable有一个call()方法相当于Runnable的run()方法，但是功能却更加强大：

call()方法可以有返回值 
call()方法可以声明抛出异常

Callable接口有泛型限制，Callable接口里的泛型形参类型与call()方法的返回值类型相同。 
而且Callable接口是函数式接口，因此可使用Lambda表达式创建Callable对象 
Runnable接口也是函数式接口，因此也可以使用Lambda表达式创建Runnable对象

  1. 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，再创建Callable实现类的实例
  2. 使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法
  3. 使用FutureTask类对象作为Thread对象的target创建并启动新线程
  4. 调用FutureTask对象的get()方法来获得子线程结束后的返回值
public class ThirdThread implements Callable<Integer> {
    public Integer call(){
        int i=0;
        for(;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
        return i;
    }

    public static void main(String[] args){
        ThirdThread tt=new ThirdThread();
        FutureTask<Integer> task=new FutureTask<>(tt);
        Thread t=new Thread(task,"有返回值的线程");
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
            if(i==20){
                t.start();
            }
        }
        try{
            System.out.println("返回值是："+task.get());
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

使用Lambda表达式的Callable和Future创建的线程

public class ThirdThread{
    public static void main(String[] args){
        ThirdThread tt=new ThirdThread();
        //先使用Lambda表达式创建Callable<Integer>对象
        //使用FutureTask封装Callable对象
        FutureTask<Integer> task=new FutureTask<Integer>((Callable<Integer>)()->{
            int i=0;
            for(;i<100;i++){
                System.out.println(Thread.currentThread().getName()+"的循环变量i的值:"+i);
            }
            return i;
        });

        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"的循环变量i的值:"+i);
            if(i==20){
                new Thread(task,"有返回值的线程").start();
            }
        }
        try{
            System.out.println("子线程的返回值"+task.get());
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
痴书先生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程建立
05-16
C++控制台程序，用于最简单的创建多线程，和容器的同时访问
第一章 线程
qq_39354297的博客
09-08 287
第一章 线程 1.1 多线程原理 画一个多线程执行时序图来体现一下多线程程序的执行流程。代码如下：自定义线程类： 1 public class MyThread extends Thread { 2 /* 3 * 利用继承中的特点 4 * 将线程名称传递 进行设置 5 */ 6 ...
0 多线程之创建多线程的四种方式
weixin_44484668的博客
03-05 854
方式一：继承Thread类的方式： 创建一个继承于Thread类的子类 重写Thread类的run() --> 将此线程执行的操作声明在run()中 创建Thread类的子类的对象 通过此对象调用start()：start（）作用①启动当前线程 ② 调用当前线程的run() 输出100以内的偶数 //1. 创建一个继承于Thread类的子类 class MyThread extends Thread { // 2. 重写Thread类的run() --&gt
创建多线程的四种方法
adieu_c的博客
04-13 1007
四种创建多线程的方法，你get到了吗？~~~
创建多线程的4种方式
W1550547162的博客
10-12 453
本文阐述了学习多线程时的四种多线程创建的方式
多线程创建的几种方式
shang_bo_liang的博客
04-26 1898
第一种方式： 创建：编写一个类 MyThread1 （这里只是小生的自定义命名，方便与代码里名称一致）让它继承 Thread 类， 并把需要多线程运行的程序放到 public void run() 方法里。 启动：在主函数中，new 出 MyThread1 类的实例。 运行：调用 MyThread1类的实例的 start() 方法即可。 第二种方式： 创建：编写一个类 MyThrea...
java多线程作业.docx
06-29
Java语言的一大特性点就是内置对多线程的支持。多线程是指一个应用程 序中同时存在几个执行体,按几条不同的执行线索共同工作的情况,它使得编 微课视频 程人员可以很方便地开发出具有多线程功能、能同时处理多个任务...
Python批量启动多线程代码实例
12-20
这篇文章主要介绍了python批量启动多线程代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 建立一个线程池，并将某个线程放入进去 threadpool = [] th ...
VB.net多线程编程.pdf
11-02
尽管由于多个事务多多少少地同时运行使多线程应用程序效率更 高，但是使用先前版本的Visual Basic很难建立这类程序。 多线程程序是可行的，因为操作系统是多任务的，它有模拟同一-时刻运行多 个应用程序的能力。尽管...
使用python多线程下载在线视频
08-05
使用python多线程下载在线视频，然后进行视频合并。 需要事先取得在线视频地址或m3u8文件地址，运行后输入，会自动建立临时文件夹，等视频文件全部下载完后，会生成cmd文件，运行会进行视频，需要使用ffmpeg。
多线程的创建
遇安的博客
04-23 2610
创建方式一：继承Thread类创建多线程 public class 多线程_1创建 { public static void main(String[] args) { //创建方式一 Thread t=new MyThread();//创建MyThread线程对象 //直接调run()方法会被当成普通方法执行，此时相当于还是单线程执行， // 所以需要调用start()方法启动多线程 t.start();//调.
【多线程】三种实现方案
ggjklncffd的博客
11-13 2430
实现线程的三种方案
学习多线程，创建多线程的三种方式
weixin_45627271的博客
09-04 1619
学习多线程，创建多线程的三种方式
创建多线程（8种方式）
qq_1757537040的博客
03-29 9125
无论有多少种形式，创建多线程的真正的方法， 其实只有两种： > 继承 Thread 类 > 实现 Runnable 接口 其它形式都是这两种方式的变体。 1、继承 Thread 类 ①实现方式 第一步：继承 Thread 类 第二步：重写 run() 方法 第三步：创建 Thread 子类对象 第四步：调用 start() 方法启动线程 ②start() 方法和 run() 方法区别 调用 run() 方法仅仅只是调用了一个子类中重写的父类...
JAVA多线程实现的三种方式
热门推荐
步春良
07-31 56万+
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 1、继承Thread类实现多线程 继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例
java创建线程的三种方式及其对比
longshengguoji的专栏
11-14 17万+
Java中创建线程主要有三种方式： 一、继承Thread类创建线程类 （1）定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 （2）创建Thread子类的实例，即创建了线程对象。 （3）调用线程对象的start()方法来启动该线程。 package com.thread; public class Firs
多线程详解
qq_38788128的博客
06-25 216
转：https://blog.csdn.net/c10wtiybq1ye3/article/details/78212045进程与线程进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的CPU 时间片。由于 CP...
JAVA多线程实现的三种方式及内部原理
honghailiang的专栏
06-16 5740
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 1、继承Thread类实现多线程 继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的
多线程建立tcp连接net.createConnection
最新发布
06-09
在 Node.js 中，可以使用 `net.createConnection()` 方法来建立 TCP 连接，并且...需要注意的是，在多线程并发的情况下，同一客户端在不同的工作进程中可能会建立多个连接，因此需要考虑如何合理地管理和维护这些连接。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值