【Java进阶】Java线程间通讯的几种方式

已于 2024-01-04 19:17:55 修改
阅读量2w 收藏 73
点赞数 18
分类专栏： Java进阶之路 文章标签： 线程 java
于 2018-11-06 20:28:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wlddhj/article/details/83793709
版权

文章目录

一、使用同一个共享变量控制

1、Synchronized、wait、notify

public class Demo1 {

    private final List<Integer> list =new ArrayList<>();

    public static void main(String[] args) {
        Demo1 demo =new Demo1();
        new Thread(()->{
            for (int i=0;i<10;i++){
                synchronized (demo.list){
                    if(demo.list.size()%2==1){
                        try {
                            demo.list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    demo.list.add(i);
                    System.out.print(Thread.currentThread().getName());
                    System.out.println(demo.list);
                    demo.list.notify();
                }
            }

        }).start();

        new Thread(()->{
            for (int i=0;i<10;i++){
                synchronized (demo.list){
                    if(demo.list.size()%2==0){
                        try {
                            demo.list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    demo.list.add(i);
                    System.out.print(Thread.currentThread().getName());
                    System.out.println(demo.list);
                    demo.list.notify();
                }
            }
        }).start();
    }
}

这段代码演示了如何使用synchronized、wait和notify来实现两个线程间的通信，以确保它们交替地向一个ArrayList中添加数字。以下是代码的详细解释：

  1. 类定义:

    • Demo1类中有一个私有的、不可变的（由final修饰）成员变量list，它是ArrayList<Integer>类型的。

  2. 主函数:

    • 在main方法中，首先创建了Demo1的一个实例demo。
    • 然后启动了两个线程，每个线程都执行一个特定的任务。

  3. 第一个线程的任务:

    • 使用一个for循环，循环10次。
    • 在每次循环中，首先获得demo.list的锁，这是通过synchronized (demo.list)实现的。
    • 检查当前列表的大小是否为奇数（通过demo.list.size()%2==1）。如果是，则调用demo.list.wait()使当前线程进入等待状态，并释放demo.list的锁，这样其他线程可以获取该锁并执行其任务。
    • 当线程从等待状态被唤醒时（通过另一个线程的notify调用），它会继续执行，并将当前的数字添加到列表中。
    • 打印当前线程的名称和更新后的列表。
    • 通过调用demo.list.notify()唤醒可能正在等待的另一个线程。

  4. 第二个线程的任务:

    • 它的工作方式与第一个线程非常相似，但有一个关键的区别：它检查列表的大小是否为偶数，并在这种情况下使线程进入等待状态。

  5. 交替执行:

    • 由于两个线程的工作方式，它们将交替地向列表中添加数字。当一个线程发现列表的大小是其期望的（奇数或偶数）时，它会暂停并等待另一个线程添加一个数字。然后，它会被另一个线程的notify调用唤醒，继续其执行，并再次使另一个线程等待。

  6. 注意事项:

    • 使用wait和notify时，必须在同步块或方法中这样做，否则会抛出IllegalMonitorStateException。
    • 当多个线程可能访问共享资源（在这里是demo.list）时，使用同步是必要的，以确保数据的完整性和一致性。
    • 虽然在这个特定的例子中只有两个线程，但这种方法可以扩展到更多的线程，只要它们遵循相同的通信和同步协议。

  7. 潜在问题:

    • 这个代码可能存在一个潜在的问题，即“假唤醒”。理论上，一个线程可能会无故地（或由于系统中的其他原因）从wait方法中唤醒，即使没有其他线程明确地调用了notify或notifyAll。为了避免这种情况导致的问题，通常在wait调用周围使用一个循环来检查预期的条件是否仍然成立。如果条件不满足，则继续等待。这通常被称为“条件变量”的使用模式。

2、Lock、Condition

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
public class Task {  
    // 创建一个可重入锁，用于同步访问共享资源（即列表）  
    private final Lock lock = new ReentrantLock();  
    // 创建两个条件变量，一个用于表示列表未满，一个用于表示列表非空  
    private final Condition notFull = lock.newCondition();  
    private final Condition notEmpty = lock.newCondition();  
  
    // 定义列表的最大容量  
    private static final int MAX_SIZE = 10;  
    // 创建一个ArrayList作为共享资源，用于在两个线程之间传递数据  
    private final List<String> list = new ArrayList<>(MAX_SIZE);  
  
    // add方法用于向列表中添加元素  
    public void add() {  
        for (int i = 0; i < 10; i++) {  
            lock.lock(); // 获取锁，开始同步代码块  
            try {  
                // 如果列表已满，则当前线程等待，直到其他线程从列表中移除元素  
                while (list.size() == MAX_SIZE) {  
                    notFull.await(); // 等待列表不满的条件成立  
                }  
                // 模拟耗时操作（比如网络请求或数据处理）  
                Thread.sleep(100);  
                // 向列表中添加一个新元素，并打印相关信息  
                list.add("add " + (i + 1));  
                System.out.println("The list size is " + list.size());  
                System.out.println("The add thread is " + Thread.currentThread().getName());  
                System.out.println("-------------");  
                // 通知可能在等待的移除线程，现在列表不为空，可以执行移除操作了  
                notEmpty.signal();  
            } catch (InterruptedException e) {  
                // 打印异常信息，实际开发中可能需要更复杂的错误处理逻辑  
                e.printStackTrace();  
            } finally {  
                lock.unlock(); // 释放锁，允许其他线程访问同步代码块  
            }  
        }  
    }  
  
    // sub方法用于从列表中移除元素  
    public void sub() {  
        for (int i = 0; i < 10; i++) {  
            lock.lock(); // 获取锁，开始同步代码块  
            try {  
                // 如果列表为空，则当前线程等待，直到其他线程向列表中添加元素  
                while (list.isEmpty()) {  
                    notEmpty.await(); // 等待列表非空的条件成立  
                }  
                // 模拟耗时操作（比如网络请求或数据处理）  
                Thread.sleep(100);  
                // 从列表中移除第一个元素，并打印相关信息  
                list.remove(0);  
                System.out.println("The list size is " + list.size());  
                System.out.println("The sub thread is " + Thread.currentThread().getName());  
                System.out.println("-------------");  
                // 通知可能在等待的添加线程，现在列表不满，可以执行添加操作了  
                notFull.signal();  
            } catch (InterruptedException e) {  
                // 打印异常信息，实际开发中可能需要更复杂的错误处理逻辑  
                e.printStackTrace();  
            } finally {  
                lock.unlock(); // 释放锁，允许其他线程访问同步代码块  
            }  
        }  
    }  
  
    // main方法作为程序的入口点，创建Task对象并启动两个线程来执行add和sub方法  
    public static void main(String[] args) {  
        Task task = new Task(); // 创建Task对象，它包含共享资源和同步机制  
        // 使用Lambda表达式和方法引用启动两个线程，分别执行add和sub方法，并为它们设置名称以便区分输出中的信息来源  
        new Thread(task::add, "AddThread").start(); // 启动添加线程  
        new Thread(task::sub, "SubThread").start(); // 启动移除线程  
    }  
}

这段代码定义了一个名为Task的类，它主要实现了线程安全的列表添加和移除操作。类内部使用了java.util.concurrent.locks包下的ReentrantLock可重入锁以及相关的Condition条件变量来同步访问共享资源（即一个ArrayList）。

在Task类中，有两个主要的方法：add和sub。add方法用于向列表中添加元素，而sub方法用于从列表中移除元素。这两个方法在被调用时都需要获取锁，以确保同一时间只有一个线程可以访问共享资源。

当添加线程调用add方法时，它首先检查列表是否已满。如果已满，则通过调用notFull.await()使当前线程等待，直到其他线程从列表中移除元素并发出通知。一旦列表不满，添加线程就会向列表中添加一个新元素，并通过调用notEmpty.signal()通知可能在等待的移除线程。

类似地，当移除线程调用sub方法时，它首先检查列表是否为空。如果为空，则通过调用notEmpty.await()使当前线程等待，直到其他线程向列表中添加元素并发出通知。一旦列表非空，移除线程就会从列表中移除一个元素，并通过调用notFull.signal()通知可能在等待的添加线程。

这种使用锁和条件变量的方式实现了线程间的同步和通信，确保了共享资源（即列表）在任何时候都不会被多个线程同时修改，从而避免了数据竞争和不一致的问题。同时，通过条件变量的等待和通知机制，有效地协调了添加线程和移除线程的执行顺序，使得它们能够按照预期的方式交替进行添加和移除操作。

3、利用volatile

volatile修饰的变量值直接存在主内存里面，子线程对该变量的读写直接写住内存，而不是像其它变量一样在local thread里面产生一份copy。volatile能保证所修饰的变量对于多个线程可见性，即只要被修改，其它线程读到的一定是最新的值。

public class Demo2 {
    private volatile List<Integer> list =new ArrayList<>();
    public static void main(String[] args) {
        Demo2 demo =new Demo2();
        new Thread(()->{
            for (int i=0;i<10;i++){
                    demo.list.add(i);
                    System.out.print(Thread.currentThread().getName());
                    System.out.println(demo.list);
            }

        }).start();

        new Thread(()->{
            for (int i=0;i<10;i++){
                    demo.list.add(i);
                    System.out.print(Thread.currentThread().getName());
                    System.out.println(demo.list);
                }
        }).start();
    }
}

4、利用AtomicInteger

和volatile类似

二、PipedInputStream、PipedOutputStream

这里用流在两个线程间通信，但是Java中的Stream是单向的，所以在两个线程中分别建了一个input和output

public class PipedDemo {

    private final PipedInputStream inputStream1;
    private final PipedOutputStream outputStream1;
    private final PipedInputStream inputStream2;
    private final PipedOutputStream outputStream2;

    public PipedDemo(){
        inputStream1 = new PipedInputStream();
        outputStream1 = new PipedOutputStream();
        inputStream2 = new PipedInputStream();
        outputStream2 = new PipedOutputStream();
        try {
            inputStream1.connect(outputStream2);
            inputStream2.connect(outputStream1);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    /**程序退出时，需要关闭stream*/
    public void shutdown() throws IOException {
        inputStream1.close();
        inputStream2.close();
        outputStream1.close();
        outputStream2.close();
    }


    public static void main(String[] args) throws IOException {
        PipedDemo demo =new PipedDemo();
        new Thread(()->{
            PipedInputStream in = demo.inputStream2;
            PipedOutputStream out = demo.outputStream2;

            for (int i = 0; i < 10; i++) {
                try {
                    byte[] inArr = new byte[2];
                    in.read(inArr);
                    System.out.print(Thread.currentThread().getName()+": "+i+" ");
                    System.out.println(new String(inArr));
                    while(true){
                        if("go".equals(new String(inArr)))
                            break;
                    }
                    out.write("ok".getBytes());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }).start();

        new Thread(()->{
            PipedInputStream in = demo.inputStream1;
            PipedOutputStream out = demo.outputStream1;

            for (int i = 0; i < 10; i++) {
                try {
                    out.write("go".getBytes());
                    byte[] inArr = new byte[2];
                    in.read(inArr);
                    System.out.print(Thread.currentThread().getName()+": "+i+" ");
                    System.out.println(new String(inArr));
                    while(true){
                        if("ok".equals(new String(inArr)))
                            break;
                    }

                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }).start();
//        demo.shutdown();
    }
}

输出

Thread-0: 0 go
Thread-1: 0 ok
Thread-0: 1 go
Thread-1: 1 ok
Thread-0: 2 go
Thread-1: 2 ok
Thread-0: 3 go
Thread-1: 3 ok
Thread-0: 4 go
Thread-1: 4 ok
Thread-0: 5 go
Thread-1: 5 ok
Thread-0: 6 go
Thread-1: 6 ok
Thread-0: 7 go
Thread-1: 7 ok
Thread-0: 8 go
Thread-1: 8 ok
Thread-0: 9 go
Thread-1: 9 ok

三、利用BlockingQueue

BlockingQueue定义的常用方法如下:

  • add(Object)：把Object加到BlockingQueue里，如果BlockingQueue可以容纳，则返回true，否则抛出异常。
  • offer(Object)：表示如果可能的话，将Object加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false。
  • put(Object)：把Object加到BlockingQueue里，如果BlockingQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里有空间再继续。
  • poll(time)：获取并删除BlockingQueue里排在首位的对象，若不能立即取出，则可以等time参数规定的时间，取不到时返回null。当不传入time值时，立刻返回。
  • peek()：立刻获取BlockingQueue里排在首位的对象，但不从队列里删除，如果队列为空，则返回null。
  • take()：获取并删除BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的对象被加入为止。

BlockingQueue有四个具体的实现类：

  • ArrayBlockingQueue：数组阻塞队列，规定大小，其构造函数必须带一个int参数来指明其大小。其所含的对象是以FIFO（先入先出）顺序排序的。
  • LinkedBlockingQueue：链阻塞队列，大小不定，若其构造函数带一个规定大小的参数，生成的BlockingQueue有大小限制，若不带大小参数，所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定。其所含的对象是以FIFO顺序排序的。
  • PriorityBlockingQueue：类似于LinkedBlockingQueue,但其所含对象的排序不是FIFO，而是依据对象的自然排序顺序或者是构造函数所带的Comparator决定的顺序。
  • SynchronousQueue：特殊的BlockingQueue，它的内部同时只能够容纳单个元素，对其的操作必须是放和取交替完成的。
  • DelayQueue：延迟队列，注入其中的元素必须实现 java.util.concurrent.Delayed 接口

所有BlockingQueue的使用方式类似，以下例子一个线程写入，一个线程读取，操作的是同一个Queue：

public class BlockingQueueDemo {

    public static void main(String[] args) {
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>();
        //读线程
        new Thread(() -> {
            int i =0;
            while (true) {
                try {
                    String item = queue.take();
                    System.out.print(Thread.currentThread().getName() + ": " + i + " ");
                    System.out.println(item);
                    i++;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //写线程
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    String item = "go"+i;
                    System.out.print(Thread.currentThread().getName() + ": " + i + " ");
                    System.out.println(item);
                    queue.put(item);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}
顽石九变
关注
  • 18
    点赞
  • 踩
  • 73
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Java进阶学习资料.zip
06-21
在Java进阶学习中，你需要掌握以下几个关键的知识点： 1. 高级数据结构与算法：理解并能熟练运用ArrayList、LinkedList、HashMap等集合框架，深入研究Set、Queue、Stack等接口及其实现类。同时，学习并应用高级排序...
多线程开发实战：Java实现多线程四种方式及相关方法原理
热门推荐
陈橘又青的博客
07-02 3万+
本文带大家了解Java实现多线程的四种方法以及实现多线程的重要注意事项和难点！
java线程通信的几种方式_java实现线程间通信的四种方式
weixin_42499899的博客
02-12 639
synchronized同步public class MyObject {synchronized public void methodA() {//do something....}synchronized public void methodB() {//do some other thing}}public class ThreadA extends Thread {private MyOb...
Java中的线程通信详解
最新发布
weixin_42303107的博客
07-14 67
Java中的线程通信详解 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在多线程编程中，线程之间的通信是一个重要且复杂的主题。为了确保多线程程序的正确性和效率，线程需要能够互相通信并协调工作。Java 提供了多种方式来实现线程间的通信，如 wait()、notify()、notifyAll...
Java线程之间如何通信的，有哪些方式？
Ascend1977的博客
05-29 5909
尽可能避免共享变量，因为共享变量容易引起线程安全问题。对共享变量的访问需要加锁，以保证同步访问。避免死锁问题的发生。使用锁时需要特别注意加锁和释放锁的顺序。使用条件变量时，应该确保线程在调用 await() 方法之前已经获取了锁。否则，在等待条件成立的过程中，其他线程可能会修改共享资源，导致程序出现错误。 在使用信号量时，需要正确设置信号量的个数和调用 acquire() 和 release() 方法的顺序，否则可能会出现线程阻塞或信号量无法释放的情况。管道的使用需要注意线程之间的数据传输方式，以及缓冲区的
Java多线程之间的通信方式
weixin_49698553的博客
07-06 3267
在Java中线程通信主要有以下三种方式：如果线程之间采用synchronized来保证线程安全，则可以利用wait()、notify()、notifyAll()来实现线程通信。这三个方法都不是Thread类中所声明的方法，而是Object类中声明的方法。原因是每个对象都拥有锁，所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作。并且因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。另外，这三个方法都是本地方法，并且被final修饰，无法被重写。wait()方法可以让当前线程释放对
Java中的线程通信的几种方式
u013749113的博客
05-17 1535
Java中提供了多种方式来实现线程间通信，其中最常见的方式包括synchronized关键字、wait()和notify()方法、CountDownLatch类、Semaphore类和BlockingQueue类。这些方式都可以用来实现线程之间的互斥、同步、数据共享和通信。选择哪种方式取决于具体的应用场景和需求。在使用这些方式时，需要注意线程安全和死锁等问题，以确保程序的正确性和健壮性。
Java线程之间通信方式
赵广陆
09-09 1888
目录 1 线程之间的通信方式主要有以下几种 2 共享变量 3 锁机制 4 条件变量 5 信号量 6 管道 6 join方法的实现原理 7 join方法实现顺序性原理 1 线程之间的通信方式主要有以下几种 在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？
Java线程之间如何通信
baidu_41638844的博客
06-03 895
可以通过Lock对象的newCondition()方法获取一个Condition实例，然后线程可以调用await()方法进入等待状态，直到其他线程调用signal()或signalAll()方法来唤醒它们。：Java提供了Object类的wait()、notify()和notifyAll()方法来实现线程之间的等待和通知。线程可以调用wait()方法进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它。这些方法提供了不同的线程通信机制，具体使用哪种方式取决于你的需求和场景。
java 进阶之路.zip
01-14
Java的主要特点和优势包括以下几个方面： 跨平台性（Write Once, Run Anywhere）： Java的代码可以在不同的平台上运行，只需编写一次代码，就可以在任何支持Java的设备上执行。这得益于Java虚拟机（JVM），它充当了...
Java进阶资料
01-14
在Java进阶学习中，我们会深入探讨以下几个关键领域： 1. 高级数据结构与算法：理解并掌握Java中的ArrayList、LinkedList、HashMap等集合框架的实现原理和性能特性，以及如何有效地运用它们来解决复杂问题。同时，...
java虚拟机多线程进阶篇总结
08-25
Java虚拟机多线程进阶篇总结是Java开发中一个非常重要的知识点，本节内容将会对Java虚拟机多线程进阶篇进行总结，帮助读者更好地理解Java虚拟机多线程的实现原理和应用。 一、线程池基本参数 在Java虚拟机中，...
JAVA进阶架构思维导图.rar
05-13
**Java进阶与架构师思维导图** 在深入探讨Java进阶和架构师思维之前，首先需要理解Java语言的基础知识。Java是一种广泛使用的面向对象编程语言，以其平台无关性、安全性和可移植性而闻名。从Java入门到成为一名专业...
【Java 基础篇】Java 线程通信详解
繁依Fanyi的博客
09-20 730
线程通信是指多个线程之间通过共享内存或其他通信机制来传递信息、同步动作或协作完成任务的过程。线程通信的核心目标是确保线程能够按照预定的顺序执行，并且能够安全地访问共享资源。线程同步：确保多个线程之间的操作按照一定的顺序执行，避免竞态条件和数据不一致性问题。线程等待：使线程能够等待某个条件的满足，以便在条件满足时再继续执行。线程通知：使线程能够通知其他线程某个条件已经满足，以便其他线程可以继续执行。线程唤醒：使等待状态的线程被唤醒，以便它们可以继续执行。
Java线程间通信方式
小海编码日记
04-24 1264
前文了解了线程的创建方式和状态切换，在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？线程间通信方式，从实现本质来讲，主要可以分为两大类共享内存和消息传递。
Java线程通信的几种方式
Admans的专栏
06-29 4522
有两个线程，A 线程向一个集合里面依次添加元素“abc”字符串，一共添加十次，当添加到第五次的时候，希望 B 线程能够收到 A 线程的通知，然后 B 线程执行相关的业务操作。线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想。大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式 Object 类提供了线程间通信的方法：wait()、no
Java线程间的通信方式
Wdradon的博客
06-27 5122
**定义：**当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。通信的方式：**线程同步：**即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。同步的话，仅仅传递的是控制信息，就是我什么时候运行结束，你什么时候可以来。对于线程间通信来说，线程间同步可以归纳为线程间通信的一个子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息，而线程同步只交换一些控制信息。在java中有几个关于
java线程间如何通信
weixin_42608299的博客
02-11 843
Java线程之间可以通过以下方式进行通信： 使用 wait() 和 notify() 方法，这需要使用同步代码块或同步方法。在同步代码块或同步方法中，线程可以调用 wait() 方法阻塞，并在其他线程调用 notify() 方法后恢复执行。 使用 CountDownLatch，它是一个同步辅助类，可以让一个线程等待其他线程的完成。 使用 CyclicBarrier，它也是一个同步辅助类，可以...
Java并发学习 7: 线程之间的通信
过道
04-10 2847
3.1 继承 Thread类 // 继承，则Demo1 也成为了一个线程 public class Demo1 extends Thread { // 继承Thread类，需要重写run()方法，告诉这个类需要去坐什么. @Override public void run() { // 这个新类，只需要打印出自己的名字(每个线程都有自己的Name属性并提供g...
Java中，线程实现的几种方式
07-12
在Java中，线程可以通过以下几种方式实现： 1. 继承Thread类：可以创建一个继承自Thread类的子类，并重写run()方法来定义线程的执行逻辑。然后通过创建该子类的实例来启动线程。 ```java class MyThread extends Thread { public void run() { // 线程执行逻辑 } } // 创建并启动线程 MyThread thread = new MyThread(); thread.start(); ``` 2. 实现Runnable接口：可以创建一个实现了Runnable接口的类，并实现run()方法，然后通过创建该类的实例作为参数来构造Thread对象，并调用start()方法启动线程。 ```java class MyRunnable implements Runnable { public void run() { // 线程执行逻辑 } } // 创建并启动线程 Thread thread = new Thread(new MyRunnable()); thread.start(); ``` 3. 使用Callable和Future：可以创建一个实现了Callable接口的类，并实现call()方法，该方法可以返回一个结果。然后通过创建ExecutorService线程池的实例，调用submit()方法提交Callable任务，并返回一个Future对象，通过调用Future对象的get()方法可以获取任务执行的结果。 ```java import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; class MyCallable implements Callable<String> { public String call() throws Exception { // 线程执行逻辑 return "Result"; } } // 创建线程池 ExecutorService executor = Executors.newFixedThreadPool(1); // 提交任务并获取Future对象 Future<String> future = executor.submit(new MyCallable()); // 获取任务执行结果 String result = future.get(); // 关闭线程池 executor.shutdown(); ``` 这些是Java中常用的线程实现方式，每种方式都有其适用的场景和特点，可以根据具体需求选择合适的方式来实现多线程。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

顽石九变

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

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

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

打赏作者

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

抵扣说明：

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

余额充值