Java多线程基础实现

最新推荐文章于 2024-08-28 10:25:48 发布
最新推荐文章于 2024-08-28 10:25:48 发布
阅读量156 收藏
点赞数
分类专栏： Java基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43633784/article/details/105196459
版权

1. 线程与进程

  • Java是一门为数不多的多线程支持的编程语言。
  • 什么是进程？在操作系统的定义中，进程指的是一次程序的完整运行，在这个运行的过程中内存、处理器、IO等资源操作都要为这个进程进行服务。在最早的DOS时代，有一个特点：如果你电脑病毒发作了，那么你的电脑几乎就不能动了。因为所有的资源都被病毒软件所占用，其他程序无法抢占这个资源。到了Windows时代电脑中病毒了，电脑也可以运行（就是慢点）。
    Windows属于多进程的操作系统，每一个进程都需要有资源的支持，多个进程怎么分配资源呢？
  • 在同一个时间段上，会有多进程轮流去抢占资源，但是在某一个时间点上，只有一个进程。
  • 线程是在进程的基础上划分的结果，即：一个进程上可以同时创建多个线程。
  • 线程是比进程更快的内存处理单元，而且所占的资源也小。多线程的应用也是性能最高的应用。
  • 线程的存在离不开进程，进程如果消失后，线程一定会消失；线程消失后，进程不一定会消失

2.Thread类实现

掌握java中三种多线程的实现方式（JDK1.5之后增加了第三种）
如果要想在java中实现多线程，有两种途径：

  • 继承Thread类
  • 实现Runnable接口（Callable接口）
继承Thread类

Thread是一个支持多线程的一个功能类，只要有一个子类就可以多线程的支持。

在这里插入图片描述

  • 所有程序的起点都是main（）方法，但是所有线程也一定要有一个自己的起点，那就是run（）方法，也就是说在多线程的每个主体类
  • 在多线程的每个主体类之中都必须覆写Thread类中所提供的run方法
    在这里插入图片描述
    这个方法上没有返回值，也就意味着线程一旦开始就要一直执行不能返回内容。
//线程操作主类
class MyThread extends Thread{//这就是一个多线程的操作类
    private  String name;
    public MyThread(String  name)
    {
        this.name=name;
    }
    @Override
    public void run() {//覆写run方法作为线程的主题操作方法
       for(int x=0;x<200;x++)
       {
           System.out.println(this.name+"-->"+x);
       }
    }
}

public class Main {//主类

    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
        MyThread m1 = new MyThread("threadA");
        MyThread m2 = new MyThread("threadb");
        m1.run();
        m2.run();

    }
}

//本线程类的功能是进行循环的输出操作，所有的线程与进程是一样的，都必须去轮流抢占资源，多线程的执行，应该是多线程彼此交替执行
//也就是说如果直接调用run（）方法，那么并不能够启动多线程，多线程启动的唯一方法就是Thread类中的Start方法：

在这里插入图片描述

  • public void start()调用此方法执行的方法体是run方法定义的
//线程操作主类
class MyThread extends Thread{//这就是一个多线程的操作类
    private  String name;
    public MyThread(String  name)
    {
        this.name=name;
    }
    @Override
    public void run() {//覆写run方法作为线程的主题操作方法
       for(int x=0;x<200;x++)
       {
           System.out.println(this.name+"-->"+x);
       }
    }
}
//本线程类的功能是进行循环的输出操作，所有的线程与进程是一样的，都必须去轮流抢占资源，多线程的执行，应该是多线程彼此交替执行
//也就是说如果直接调用run（）方法，那么并不能够启动多线程，多线程启动的唯一方法就是Thread类中的Start方法
public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
        MyThread m1 = new MyThread("threadA");
        MyThread m2 = new MyThread("threadB");
        m1.start();
        m2.start();
    }
}

在这里插入图片描述
此时，每个thread是交替执行的，它们执行的东西都是一样的。要想启动多线程就要调用start（）
为什么多线程启动不是调用run而必须调用start（）？
看一下java的源代码中start的定义：

 public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
//是否被启动一次
        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);
        boolean started = false;
        try {
            start0();//关键
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }
   private native void start0();
  1. 首先发现在Thread类的start方法里面存在这样一个异常抛出：IllegalThreadStateException();本方法里面使用throw抛出异常，通常道理上应该用try…catch处理或者在start方法上使用throws声明，但是此处并没有这样的代码，因为此异常属于RuntimeException的子类属于选择性处理
    在这里插入图片描述
    在这里插入图片描述
    如果一个线程对象重复启动就会抛出此异常
  2. 发现在start方法中使用了start0()方法，而且此方法的结构与抽象方法类似，使用了native声明，在java开发里面有一门技术叫做JNI技术（Java Native Interface），使用Java调用本操作系统的函数，但是有一个缺点就是不能离开特定的操作系统。属于丧失这种可移植性。如果要想线程执行，需要操作系统进行资源分配。
private native void start0();

如果要想线程执行，需要操作系统来进行资源分配，所以此操作严格来讲主要是由JVM负责根据不同的操作系统来实现的。

即：使用Thread类的start（）方法不仅仅要启动多线程的一个执行代码还要根据不同的操作系统进行资源的分配。

2.实现Runnable接口

虽然Thread类是可以实现多线程的一个主体类的定义，但是它有一个问题，Java具有单继承局限，正因为如此，在任何情况下，针对类的继承都应该是回避的问题，那么多线程也一样，为了解决单继承的限制，在java里面专门提供了Runnable接口
在这里插入图片描述
函数式接口：JDK1.5之后用此接口，函数式接口的特征是一个接口只能定义一个方法，因为要作为方法引用使用

public interface Runnable{
   public void run();
   }

任何接口里面定义的方法都是public定义的权限，不允许存在默认的权限。即使不写也是public。
那么只需要让一个类实现Runnable接口即可，并且也需要覆写run方法

//线程操作主类
class MyThread implements Runnable{//这就是一个多线程的操作类
    private  String name;
    public MyThread(String  name)
    {
        this.name=name;
    }
    @Override
    public void run() {//覆写run方法作为线程的主题操作方法
       for(int x=0;x<200;x++)
       {
           System.out.println(this.name+"-->"+x);
       }
    }
}

此时的MyThread类在结构上与之前是没有区别的，但是有一点是有严重区别的，如果此时继承了Thread类，那么可以直接继承start（）方法，但如果实现的是Runnable接口没有start方法可以被继承。
不管何种情况下，要想启动多线程，要依靠Thread类完成，在Thread类里面定义有以下的构造方法：
在这里插入图片描述

public Thread(Runnable target);

这个构造方法接收实现Runnable接口的对象！

//线程操作主类
class MyThread implements Runnable{//这就是一个多线程的操作类
    private  String name;
    public MyThread(String  name)
    {
        this.name=name;
    }
    @Override
    public void run() {//覆写run方法作为线程的主题操作方法
       for(int x=0;x<200;x++)
       {
           System.out.println(this.name+"-->"+x);
       }
    }
}
//本线程类的功能是进行循环的输出操作，所有的线程与进程是一样的，都必须去轮流抢占资源，多线程的执行，应该是多线程彼此交替执行
//也就是说如果直接调用run（）方法，那么并不能够启动多线程，多线程启动的唯一方法就是Thread类中的Start方法
public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
        MyThread m1 = new MyThread("threadA");
        MyThread m2 = new MyThread("threadB");
        Thread t1 = new Thread(m1);
        Thread t2 = new Thread(m2);
        t1.start();
        t2.start();
        //m1.start();
        //m2.start();
    }
}

此时就避免了单继承局限，那么也就是说实现过程中使用接口是最合适的

3.多线程两种实现方式的区别（面试题）

首先要明确的是使用Runnable接口与Thread类相比解决了单继承的定义局限，不管后面的区别是什么，这一点上就已经下了死定义。如果要使用一定使用Runnable接口。
首先观察一下Thread类的定义。

public class Thread
extends Object
implements Runnable

MyThread和Thread都实现了Runnable接口，但是MyThread类通过Thread类实现功能：

  1. MyThread主要实现多线程类的核心功能
  2. Thread类进行操作系统的资源分配；
    调用run(){}方法（核心功能）
  • 客户端使用的是Thread类，调用的是其start方法，start方法再去调用MyThread类的核心功能。Thread起到一个代理的作用，MyThread是一个真实操作主题。
  • 整个的定义结构非常像代理设计模式，但是还有一个不太合适的地方，如果是代理设计模式，客户端调用的代理调用方法也应该是接口定义的方法也应该是run才对。
  • 除了以上的联系还有一点：使用Runnable接口可以别Thread类更好的描述出数据共享这一概念。此时的数据共享指的是多个线程访问统一资源的操作。
    范例：每一个线程对象都必须通过start启动
//线程操作主类
class MyThread extends Thread{//这就是一个多线程的操作类
    private int ticket=10;
    @Override
    public void run() {//覆写run方法作为线程的主题操作方法
       for(int x=0;x<100;x++)
       {
           if(this.ticket>0)
               System.out.println("ticket="+this.ticket--);
       }
    }
}
//本身这个类里面是有start方法的
public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
      //由于MyThread类有start方法，所以每一个MyThread类对象就是1个线程对象，可以直接启动
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        MyThread mt3 = new MyThread();
        mt1.start();
        mt2.start();
        mt3.start();
        //m2.start();
    }
}

//本程序声明了三个MyThread类的对象，并且分别调用了三次start方法启动线程对象
//但是发现每一个线程都在卖各自的10张票，因为开辟了三个同样的内存空间
此时并不存在有数据共享这一概念
范例：利用Runnable实现

   MyThread mt1 = new MyThread();
        MyThread mt2 = mt1;
        MyThread mt3 = mt1;
        mt1.start();
        mt2.start();
        mt3.start();

//线程操作主类
class MyThread implements Runnable{//这就是一个多线程的操作类
    private int ticket=10;
    @Override
    public void run() {//覆写run方法作为线程的主题操作方法
       for(int x=0;x<100;x++)
       {
           if(this.ticket>0)
               System.out.println("ticket="+this.ticket--);
       }
    }
}
//本身这个类里面是有start方法的
public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
      //由于MyThread类有start方法，所以每一个MyThread类对象就是1个线程对象，可以直接启动
        MyThread mt1 = new MyThread();
        new Thread(mt1).start();
        new Thread(mt1).start();
        new Thread(mt1).start();
    }
}

在这里插入图片描述
整个代码中有三个线程类对象，但是在空间中是怎么存的？
在这里插入图片描述
此时也属于三个线程对象的，但是唯一的区别就是这三个线程对象都占用了同一个MyThread类对象的空间，也就是说这三个线程对象都直接访问同一个数据资源。
以后多个线程对象访问一块内存资源就使用Runnable接口定义线程主体类，用Thread类启动线程。
面试题：请解释Thread类与Runnable接口实现多线程的区别？（请解释多线程两种实现方式的区别）

  • Thread类是Runnable接口的子类，使用Runnable接口实现多线程可以避免单继承的局限
  • Runnable接口实现的多线程可以比Thread类实现的多线程更加清楚的描述数据共享的概念。（还是没太理解？？？）
    面试题：请写出多线程的两种实现操作？
    把上面的代码都写出来，把Thread类继承的方式和Runnable接口的实现方法都写出来

4.Callable接口（理解）

使用Runnable接口实现的多线程可以避免单继承的局限，但是有一个问题，不能返回操作结果。为了解决这样的矛盾，提供了一个新的接口：Callable接口

@FunctionalInterface
public interface Callable<V>
{public V call();}

在这里插入图片描述
执行完主题功能之后可以返回一个结果，而返回结果的类型由Callable接口上的泛型来决定。
范例：定义一个线程主体类

import java.util.concurrent.Callable;

//线程操作主类
class MyThread implements Callable<String> {//这就是一个多线程的操作类
    private int ticket=10;
    @Override
    public String call ()throws Exception {//覆写run方法作为线程的主题操作方法
       for(int x=0;x<100;x++)
       {
           if(this.ticket>0)
               System.out.println("ticket="+this.ticket--);
       }
       return "票已卖光";
    }
}
//此时观察Thread方法类中没有实现Callable的接口
//本身这个类里面是有start方法的接口

在JDK1.5之后有一个public class FutureTask<V>类，这个类主要是负责Callable接口对象操作的，这个接口的定义结构：

public class FutureTask<V>
extends Object
implements RunnableFuture<V>

实现了一个RunnableFuture接口：

public interface RunnableFuture<V>
extends Runnable, Future<V>

public interface Future的方法：
在这里插入图片描述
在FutureTask里面有如下的构造方法：
在这里插入图片描述

接收的目的只有一个：取得call（）方法的返回结果。

import java.awt.*;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

//线程操作主类
class MyThread implements Callable<String> {//这就是一个多线程的操作类
    private int ticket=10;
    @Override
    public String call ()throws Exception {//覆写run方法作为线程的主题操作方法
       for(int x=0;x<100;x++)
       {
           if(this.ticket>0)
               System.out.println("ticket="+this.ticket--);
       }
       return "票已卖光";
    }
}
//此时观察Thread方法类中没有实现Callable的接口
//本身这个类里面是有start方法的
public class Main {//主类
    public static void main(String[] args) throws Exception {//正常工作一定要通过try catch处理
      //由于MyThread类有start方法，所以每一个MyThread类对象就是1个线程对象，可以直接启动
        MyThread mt1 = new MyThread();
        FutureTask<String > task1 = new FutureTask<String>(mt1);
        MyThread mt2 = new MyThread();
        FutureTask<String > task2 = new FutureTask<String>(mt1);
        //为了取得call的返回结果
        //Runnable的接口子类，所以可以使用Thread类的构造来接收task对象
        //启动线程
        new Thread(task1).start();
        new Thread(task2).start();
        //多线程执行完毕之后可以取得内容，依靠FutureTask的父接口Future中的get方法完成
        System.out.println("A线程的返回结果"+task1.get());
        System.out.println("B线程的返回结果"+task2.get());
        }
}

最麻烦的问题是需要接收返回值的信息，并且又要与原始的多线程的实现靠拢（向Thread类靠拢）

总结
  1. 对于多线程的实现，重点在于Runnable接口和Thread类启动的配合上
  2. 对于JDK1.5的新特性，了解知道区别在于返回结果上
pudding_art
关注
专栏目录
JAVA中实现多线程
Zhanhan15977的博客
05-15 5565
一，JAVA中实现多线程（一） 1，在Java中负责线程的这个功能的是Java.lang.Thread 这个类 2，可以通过创建 Thread 的实例来创建新的线程。 3，每个线程都是通过某个特定Thread对象所对应的方法run( )来完成其操作的，方法run( )称为线程体。 4，通过调用Thead类的start()方法来启动一个线程。 二，创建线程的方式一继承Thread类 操作步骤： 【1】继承Thread类 【2】重写run方法 【3】创建对象，调用start()方法启动线程 三
Java多线程干货系列（1）Java多线程基础编程开发技术
11-22
Java多线程是Java编程中的重要...以上内容仅涵盖了Java多线程基础编程的一部分知识点，实际开发中还需要关注更多的并发控制策略、性能优化和调试技巧。对于深入理解Java多线程，还需要学习和实践更多相关的高级特性。
JAVA多线程实现和应用总结
weixin_34405354的博客
01-09 465
最近在做代码优化时学习和研究了下JAVA多线程的使用，看了菜鸟们的见解后做了下总结。1.JAVA多线程实现方式JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。 2.继承Thread类实现多线程继承T...
多线程篇（并发编程 - Java线程实现方式）（持续更新迭代）
最新发布
wlcass zhengge blog
08-28 866
自定义线程 ThreadDemo，ThreadDemo类继承了Thread类，并重写了 run() 方法。在 main 函数里面创建了一个 MyThread 的实例，然后调用该实例的 start 方法启动了线程。当创建完 thread 对象后该线程并没有被启动执行，直到调用了start方法后才真正启动了线程，也就是说在线程未调用 start()方法时，前面所走的程序还是属于单线程程序，那么 start 就意味着开启多线程！
Java多线程实现
L.
09-11 140
一、线程与进程 从操作系统来讲，可以被民用的系统最早是DOS，但是传统的DOS系统有一个特征：电脑出现病毒之后系统会死机，因为传统的DOS系统采用的是单进程的处理方式。而后来到了windows时代，那么采用的是多进程的处理方式，在同一个时间段上会有多个程序并发执行，轮流强占CPU资源。 但是进程的启动和销毁还是很慢的。所以后来人们开始尝试在进程上做进一步的优化，那么就产生了线程的概念，即：...
Java多线程实现四种方式原理详解
08-19
这些方式都是Java多线程实现的基础，理解这些方式对Java开发者来说非常重要。 1. 继承Thread类 继承Thread类是Java中最基本的多线程实现方式。通过继承Thread类，并重写run方法，可以实现自己的线程代码。在这个...
Java多线程知识点总结
08-19
总之，掌握Java多线程的生命周期、创建、启动、同步以及线程池的使用是编写高效、稳定并发程序的基础。理解这些知识点对于解决并发编程中的问题，比如资源竞争、死锁、线程安全性等问题，至关重要。在实际开发中，...
java多线程读取多个文件的方法
08-25
首先，本文涉及到的核心类是`Thread`类，这是Java中实现多线程的基础。在Java中，通过继承`Thread`类或者实现`Runnable`接口，可以创建一个线程。由于`Thread`类本身就是实现了`Runnable`接口的，因此这里继承`...
一篇文章弄懂Java多线程基础和Java内存模型
12-21
Java多线程是并发编程的重要组成部分，理解和掌握其基础以及Java内存模型对于任何Java开发者来说都是必不可少的。本文将深入探讨这两个主题。 首先，我们来理解多线程的生命周期及其五种基本状态： 1. 新建状态...
Java 多线程实现
程序员学习圈
04-16 214
1.线程的概念：    什么是程序(program ):为了完成某项特定的任务，使用某种语言，编写一组指令的集合。即指一段静态的代码，静态对象。    什么是进程(process ): 程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。    什么是线程(thread ):在一个进程中，执行的一套功能流程，称为线程。                      ...
java多线程实现
吻得太逼真的博客
10-10 135
1.线程的生命周期 2.创建线程的方式，继承Thread和实现Runnable接口 package it.com.cn.thread; public class ThreadCreate { public static void main(String[] args) { MyThread myThread = new MyThread();...
Java多线程的实现
qq_43185543的博客
09-02 166
Java多线程的实现： 1.继承Thread类 步骤： （1）创建一个Thread线程类的子类（子线程），同时重写Thread类的run方法； （2）创建稿子类的实例对象，并通过调用start（）方法启动线程。 示例1： class MyThread extends Thread { private String title; public MyThread(String title) { ...
Java之多线程的实现
HL_HLHL的博客
11-17 248
进程与线程的概念 进程：操作系统中一个程序的执行周期 线程：一个进程同时执行多个任务。通常来讲，每个任务就称为一个线程。 线程与进程比较： 1.线程更加的“轻量级”，创建、撤销一个线程比启动、撤销一个进程开销要小的多。一个进程中的所有线程共享此进程的所有资源。 2.没有进程就没有线程，进程一旦终止，其内的线程也将不复存在 3.进程是操作系统资源调度的基本单位，进程可以独享资源。线程需要依托进程提供...
java中实现多线程
Bamboo_Dong的博客
07-28 446
JAVA多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。在这里我们主要说明前两中方式。1.继承Thread类实现多线程Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方
Java实现多线程方式
m0_59500811的博客
07-03 666
Java实现多线程方式
Java---多线程--多线程的实现
chstor's blog
05-06 117
文章目录 一、多线程的实现 二、继承Thread类 三、实现Runnable接口 四、实现Callable接口 一、多线程的实现 二、继承Thread类 继承Thread类： Thread类是java.lang包下的一个线程类，用来实现java多线程。通过继承Thread类的方式来实现多线程： 为什么要重写run()方法？ 因为run()是用来封装被线程执行的代...
JAVA多线程实现方式
借你一秒
04-16 577
1. 楔子 java有多种方式实现多线程，比如继承Thread类或实现Runnable接口创建无返回值的多线程、使用ExecutorService、Callable、Future实现有返回结果的多线程等，这些该具体如何实现？各有什么不同？在什么样的场景下使用哪种方式比较好？本文就来探讨这些问题。 2.继承Thread Thread本质上也是实现了Runnable接口，他是Runnable的一个实例...
Java多线程基础与实现方式详解
在Java中实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 自定义一个类继承Thread，重写run()方法。创建该类的对象后，通过调用start()方法启动线程。但这种方式存在局限性，因为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值