Java中实现多线程关键词整理

简介:

Java中的Runable,Callable,Future,FutureTask,ExecutorService,Excetor,Excutors,ThreadPoolExcetor在这里对这些关键词,以及它们的用法做一个总结。

首先将它们分个类:
Runable,Callable
Future,FutureTask
ExecutorService,Executor,Excutors,ThreadPoolExcetor

1. 关于Ranable和Callable

首先Java中创建线程的方法有三种:

  1. 继承Thread类,覆盖run方法

  2. 实现Runable接口,实现run方法

  3. 实现Callable接口,实现run方法

三种实现的优缺点:

  1. 继承Thread,单继承的缘故,不能再继承其他类,获取当前线程this

  2. 实现Runable接口,没有返回值,获取当前线程Thread.currentThread()

  3. 实现Callable接口,可通过Future.get()获取返回值,获取当前线程 Thread.currentThread()

继承Thread,两个步骤:

class DemoThread extends Thread {    @Override
    public void run() {        super.run();        // Perform time-consuming operation...
    }
}DemoThread t = new DemoThread();
t.start();
  • 继承Thread类,覆盖run()方法。

  • 创建线程对象并用start()方法启动线程。

实现Runable,一般使用如下:

new Thread(new Runnable() {    @Override
    public void run() {        // do something
    }
}).start();

为了简单。
以上两种方式获取线程执行的结果相当麻烦,不能直接获取。JDK1.5增加了 Callable, Callable 的 call() 方法可以返回值和抛出异常。Callable 可以返回装载有计算结果的 Future 对象。
Callable的源码:

public interface Callable<V> {    V call() throws Exception;
}

Callable的基本使用方法:

FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {    @Override
    public Integer call() throws Exception {        // do something
        return null;
    }
});
Thread thread = new Thread(futureTask);
thread.start();
Integer result = futureTask.get();

运行 Callable 任务可以拿到一个 Future 对象,通过Future的get()方法拿到线程执行的返回值。那么...Future,FutureTask区别是什么,怎么使用?
->next()

2. 关于Future和FutureTask

为了获取线程的执行结果,引入了Future的FutureTask,那么他们是什么关系,如何使用?
Future类位于java.util.concurrent包下,它是一个接口:

public interface Future<V> {    boolean cancel(boolean mayInterruptIfRunning);    boolean isCancelled();    boolean isDone();    V get() throws InterruptedException, ExecutionException;    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

Future 定义了5个方法:

  1. boolean cancel(boolean mayInterruptIfRunning):试图取消对此任务的执行。如果任务已完成、或已取消,或者由于某些其他原因而无法取消,则此尝试将失败。当调用 cancel() 时,如果调用成功,而此任务尚未启动,则此任务将永不运行。如果任务已经启动,则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程。此方法返回后,对 isDone() 的后续调用将始终返回 true。如果此方法返回 true,则对 isCancelled() 的后续调用将始终返回 true。

  2. boolean isCancelled():如果在任务正常完成前将其取消,则返回 true。

  3. boolean isDone():如果任务已完成,则返回 true。 可能由于正常终止、异常或取消而完成,在所有这些情况中,此方法都将返回 true。

  4. V get()throws InterruptedException,ExecutionException:如有必要,等待计算完成,然后获取其结果。

  5. V get(long timeout,TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException: 如有必要,最多等待为使计算完成所给定的时间之后,获取其结果(如果结果可用)。

总的来说Future提供了三种功能:

  1. 判断任务是否完成;

  2. 能够中断任务;

  3. 能够获取任务执行结果。

重点
RunnableFuture继承了Runnable接口和Future接口,而FutureTask实现了RunnableFuture接口。
FutureTask的实现:

public class FutureTask<V> implements RunnableFuture<V>

RunnableFuture接口的实现:

public interface RunnableFuture<V> extends Runnable, Future<V> {    void run();
}

FutureTask是Future接口的一个唯一实现类。
除了可以用Thread包装FutureTask外,还有另一种使用方法:

ExecutorService executor = Executors.newCachedThreadPool();
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
    @Override    public Integer call() throws Exception {
        // do something        return null;
    }
});
executor.submit(futureTask);Integer result = futureTask.get();

这里用到了Executor 框架。
->next();

3. 关于ExecutorService,Executor,Excutors,ThreadPoolExcetor

Executor框架在Java 5中被引入,Executor 框架是一个根据一组执行策略调用、调度、执行和控制的异步任务的框架。
在说Executor 框架之前我们需要引入一个新的概念——线程池(ThreadPoolExecutor):

public ThreadPoolExecutor(intcorePoolSize,        int maximumPoolSize,        long keepAliveTime,
        TimeUnit unit,
        BlockingQueue<Runnable> workQueue,
        ThreadFactory threadFactory,
        RejectedExecutionHandler handler)

ThreadPoolExecutor是Executors类的底层实现。
在JDK帮助文档中,有如此一段话:

“强烈建议程序员使用较为方便的 Executors 工厂方法 Executors.newCachedThreadPool()(无界线程池,可以进行自动线程回收)、Executors.newFixedThreadPool(int)(固定大小线程池)和 Executors.newSingleThreadExecutor()(单个后台线程),它们均为大多数使用场景预定义了设置。”

那么ExecutorService,Excetor,Excutors都是什么?
Excetor是一个抽象层面的核心接口:

public interface Executor {    void execute(Runnable command);
}

ExecutorService 接口 对 Executor 接口进行了扩展,提供了返回 Future 对象,终止,关闭线程池等方法。

public interface ExecutorService extends Executor {    void shutdown();
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;
}

Executors 是一个工具类,类似于 Collections。提供工厂方法来创建不同类型的线程池,比如 FixedThreadPool 或 CachedThreadPool。

public class Executors {    public static ExecutorService newFixedThreadPool(int nThreads) {        return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
        }        
     public static ExecutorService newCachedThreadPool() {        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        }
}

以上是对Java多线程关键词的整理,不至于一团乱麻。

本文转自帅气的头头博客51CTO博客,原文链接http://blog.51cto.com/12902932/1925709如需转载请自行联系原作者


sshpp

相关文章
|
4天前
|
缓存 Java 开发者
Java多线程并发编程:同步机制与实践应用
本文深入探讨Java多线程中的同步机制,分析了多线程并发带来的数据不一致等问题,详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用,结合代码示例展示了如何有效解决竞态条件,提升程序性能与稳定性。
|
4天前
|
安全 Java 开发者
Java中的多线程编程:从基础到实践
本文深入探讨了Java多线程编程的核心概念和实践技巧,旨在帮助读者理解多线程的工作原理,掌握线程的创建、管理和同步机制。通过具体示例和最佳实践,本文展示了如何在Java应用中有效地利用多线程技术,提高程序性能和响应速度。
27 1
|
12天前
|
存储 安全 Java
Java多线程编程中的并发容器:深入解析与实战应用####
在本文中,我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构,并发容器专为多线程场景设计,确保数据访问的线程安全性和高效性。我们将从基础概念出发,逐步深入到`java.util.concurrent`包下的核心并发容器实现,如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等,通过实例代码演示其使用方法,并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者,本文都将为你提供有价值的见解与实践指导。 --- ####
|
17天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
44 9
|
20天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
17天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
|
19天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
14天前
|
Java 开发者
Java多线程编程中的常见误区与最佳实践####
本文深入剖析了Java多线程编程中开发者常遇到的几个典型误区,如对`start()`与`run()`方法的混淆使用、忽视线程安全问题、错误处理未同步的共享变量等,并针对这些问题提出了具体的解决方案和最佳实践。通过实例代码对比,直观展示了正确与错误的实现方式,旨在帮助读者构建更加健壮、高效的多线程应用程序。 ####
|
21天前
|
安全 Java 测试技术
Java并行流陷阱:为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱,尤其是指定线程池的问题。文章分析了并行流的设计思想,指出了指定线程池的弊端,并提供了使用CompletableFuture等替代方案。同时,介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
|
5天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####