Executor
execute(Runnable command);
ExecutorService
interface ExecutorService extends Executor
<T> Future<T> submit(Callable<T> task); Future<?> submit(Runnable task); <T> Future<T> submit(Runnable task, T result); ...
Future
FutureTask
public class FutureTask<V> extends Object implements Future<V>, Runnable
FutureTask(Callable<V> callable) //创建一个 FutureTask,一旦运行就执行给定的 Callable。 FutureTask(Runnable runnable, V result) //创建一个 FutureTask,一旦运行就执行给定的 Runnable,并安排成功完成时 get 返回给定的结果 。
CompletionService
//能够拿到最先完成的任务的返回值,而不管它们加入线程池的顺序
Future<V> submit(Callable<V> task); Future<V> submit(Runnable task, V result);
CyclicBarrier
//它允许一组线程互相等待,直到到达某个公共屏障点
//线程分别执行,互不影响,执行到barrier.await();时该线程进入等待状态,当几个线程都执行到barrier.await();时,达到CyclicBarrier启动所需的阻塞线程数,进入到new CyclicBarrier(2, new Runnable()...)里面的方法, 执行完里面的方法后,等待的两个线程再次被唤醒,继续各自执行线程后面的语句
CyclicBarrier(int parties) CyclicBarrier(int parties, Runnable barrierAction)
await()
Semaphore
//控制某个资源可被同时访问的个数
Semaphore(int permits) Semaphore(int permits, boolean fair)
acquire() // 获取许可
release() //访问完后释放
CountDownLath
//可用于在一批线程中,在每个线程中countDown(),在外部调用一次await(),使得各线程完成后再执行后面代码
CountDownLatch(int count)
await() //阻塞所有线程,直到其count为0
countDown() //计数器减一
AbstractQueuedSynchronizer的介绍和原理分析
AbstractQueuedSynchronizer百度百科
源码分析 一 AbstractQueuedSynchronizer
Inside AbstractQueuedSynchronizer (1)
ReentrantLock代码剖析之ReentrantLock.lock
JAVA并发-自旋锁、排队自旋锁、MCS锁、CLH锁(注意其他文章)
Example1:
利用ThreadGroup等待所有线程执行结束
public class T { public static void main(String[] args) { ThreadGroup group1 = new ThreadGroup("group-one"); for(int i=1; i<=10; i++){ new Thread(group1, new GroupThreadMem(),i+"#线程").start(); } while(group1.activeCount() > 0){ System.out.println("group1的当前的活跃数量:"+group1.activeCount()); } System.out.println("==group1中所有线程执行结束==="); } } class GroupThreadMem implements Runnable { @Override public void run() { int times = new Random().nextInt(10); while(times-- > 0){ try { Thread.sleep(50); System.out.println(Thread.currentThread().getName()); } catch (InterruptedException e) { e.printStackTrace(); } } } }
Example2:
实例模拟ReentrantLock、synchronized、ReentrantReadWriteLock三种锁在不同场景下的性能情况
代码搞起:
import java.util.Random; import java.util.concurrent.CountDownLatch; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class CurrentObject { private static Random random = new Random(); public final static int READ_NUM = 180;// 读线程数 public final static int WRITE_NUM = 20;// 写线程数 private int value;//并发需要读写的值 private ReadWriteLock lock = new ReentrantReadWriteLock(); private Lock locknew = new ReentrantLock(); //------------------------------------------------------------- /** * 通过ReentrantReadWriteLock添加读锁 * @return value * {@link ReentrantReadWriteLock} */ public int getValueLock() { lock.readLock().lock(); try { return value; } finally { lock.readLock().unlock(); } } /** * 通过ReentrantReadWriteLock添加写锁 * @param value */ public void setValueLock(int value) { lock.writeLock().lock(); try { this.value = value; } finally { lock.writeLock().unlock(); } } //------------------------------------------------------------- /** * 通过ReentrantLock添加读锁 * @return value */ public int getValueNew() { locknew.lock(); try { return value; } finally { locknew.unlock(); } } /** * 通过ReentrantLock添加写锁 * @param value */ public void setValueNew(int value) { locknew.lock(); try { this.value = value; } finally { locknew.unlock(); } } //------------------------------------------------------------- /** * 通过synchronized添加读锁 * @return value */ public synchronized int getValueSyn() { return value; } /** * 通过synchronized添加写锁 * @param value */ public synchronized void setValueSyn(int value) { this.value = value; } //------------------------------------------------------------- /** * 用于读/写平均耗时的展现 */ public static void display() { System.out.println("读平均耗时:" + (TimeCostUtils.getReadLong().get() / READ_NUM) + " ns"); System.out.println("写平均耗时:" + (TimeCostUtils.getWriteLong().get() / WRITE_NUM) + " ns"); } /** * 测试方法 * @param args * @throws InterruptedException */ public static void main(String[] args) throws InterruptedException { final CurrentObject concurrentObject = new CurrentObject(); //防止线程池大小过大,CPU过多的上下文切换导致的开销影响,线程池大小必须同总共开启的对象 int maxProcessor = READ_NUM + WRITE_NUM; final ExecutorService newFixedThreadPool = Executors .newFixedThreadPool(maxProcessor); final CountDownLatch latch = new CountDownLatch(READ_NUM + WRITE_NUM);// 最后关闭线程池 final CyclicBarrier barrier = new CyclicBarrier(READ_NUM + WRITE_NUM);// 等待所有线程启动后并发读写 for (int i = 0; i < READ_NUM; i++) { newFixedThreadPool.execute(new Runnable() { @Override public void run() { try { barrier.await(); } catch (Exception e) { e.printStackTrace(); } TimeCostUtils.start(TimeCostUtils.READ); concurrentObject.getValueLock(); //concurrentObject.getValueNew(); //concurrentObject.getValueSyn(); TimeCostUtils.end(); latch.countDown(); } }); } for (int i = 0; i < WRITE_NUM; i++) { newFixedThreadPool.execute(new Runnable() { @Override public void run() { int nextInt = random.nextInt(1000); try { barrier.await(); } catch (Exception e) { e.printStackTrace(); } TimeCostUtils.start(TimeCostUtils.WRITE); concurrentObject.setValueLock(nextInt); //concurrentObject.setValueNew(nextInt); //concurrentObject.setValueSyn(nextInt); TimeCostUtils.end(); latch.countDown(); } }); } latch.await(); newFixedThreadPool.shutdown(); // 系统退出前,关闭线程池及计算平均耗时、总耗时 Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() { @Override public void run() { display(); } })); } }
import java.util.concurrent.atomic.AtomicLong; public class TimeCostUtils { private static AtomicLong readLong = new AtomicLong(); private static AtomicLong writeLong = new AtomicLong(); public final static String WRITE = "write"; public final static String READ = "read"; static ThreadLocal<TimesRecords> recordMap = new ThreadLocal<TimesRecords>(); public static void start(String prefix) { TimesRecords timesRecords = new TimesRecords(prefix, System.nanoTime()); recordMap.set(timesRecords); } public static void end() { TimesRecords timesRecords = recordMap.get(); long cost = System.nanoTime() - timesRecords.getCost(); // 计算每次的开销时间 if (timesRecords.getName().equals(WRITE)) { writeLong.addAndGet(cost); } else { readLong.addAndGet(cost); } } public static AtomicLong getReadLong() { return readLong; } public static AtomicLong getWriteLong() { return writeLong; } static class TimesRecords { private String name; private long cost; public TimesRecords(String name, long cost) { this.name = name; this.cost = cost; } public String getName() { return name; } public void setName(String name) { this.name = name; } public long getCost() { return cost; } public void setCost(long cost) { this.cost = cost; } } }
结果:
1、ReentrantReadWriteLock
读平均耗时:93373 ns
写平均耗时:562068 ns
2、ReentrantLock
读平均耗时:32015 ns
写平均耗时:7053 ns
3、Synchoroniced
读平均耗时:39913 ns
写平均耗时:6760 ns
相关推荐
继承Thread类直接创建一个新的线程类,而实现Runnable接口则可以避免单继承的限制,更易于代码的维护和扩展。此外,还可以通过实现Callable接口并使用FutureTask包装来创建可返回结果的线程。 二、线程的生命周期 ...
第一种是通过继承Thread类并重写run方法来定义新的线程类。当创建此类的对象时,实际上就创建了一个新的线程。要启动线程,需要调用线程对象的start方法,这将让线程进入就绪状态。需要注意的是,尽管调用了start...
MFC 多线程完整总结及示例代码 多线程是一种重要的编程技术,用于实现并行处理和提高系统性能。在 MFC 中,多线程编程可以通过 Win32 API 函数和 MFC 类库来实现。在本文中,我们将对多线程的基本概念、多线程编程...
### Java多线程编程总结 #### 一、Java线程:概念与原理 1. **操作系统中线程和进程的概念** - 当前的操作系统通常为多任务操作系统,多线程是实现多任务的一种手段。 - **进程**:指内存中运行的应用程序,每个...
### Java多线程问题总结 #### 一、多线程的作用与优势 1. **发挥多核CPU的优势:** - 当今计算机硬件普遍配备有多核CPU,利用多线程技术能够有效地分配任务到不同的核心上,使得计算资源得到最大化利用。在双核...
在Java中,多线程的实现通常借助于`Thread`类或实现`Runnable`接口。多线程能够提高CPU的利用率,改善应用程序性能。 #### 2. Java中的线程生命周期 - **新建** (`NEW`):新创建的线程。 - **可运行** (`RUNNABLE`)...
### 多线程知识总结 #### 一、线程基础概念 **线程状态:** 在探讨多线程之前,我们需要了解线程的基本状态转换。一个典型的线程生命周期包括以下几个阶段: 1. **Start(启动):** 当线程被创建后调用`start()`...
在Windows应用程序开发中,MFC(Microsoft Foundation Classes)框架提供了对多线程的支持,使得开发者可以构建更加复杂的并发系统。MFC中的线程分为两类:工作者线程和用户界面线程,它们各自有不同的特性和用途。 ...
Java中实现多线程主要有两种方式:继承Thread类和实现Runnable接口。 ### 继承Thread类 在Java中,通过继承`Thread`类并重写其`run()`方法可以创建自定义线程。`Thread`类是Java提供的一个基础类,用于封装线程的...
Java多线程编程是开发高并发应用的关键技术之一。它基于操作系统的多任务、多进程概念,通过线程实现程序内部的并发执行,以充分利用CPU资源。在Java中,线程是程序执行的最小单元,它们共享同一进程的内存空间,...
在IT行业中,多线程是程序并发执行的一种方式,它极大地提高了系统资源的利用率和程序...在学习过程中,可以参考"多线程基础总结01.bmp"和"多线程基础总结01.mmap"等文件,它们可能提供了更为详细和直观的结构化知识。
C#.net同步异步SOCKET通讯和多线程总结 C#.net同步异步SOCKET通讯和多线程总结是指在C#.net环境下实现的同步异步套接字通信和多线程编程的总结。套接字(Socket)是tcp/ip网络协议接口,内部定义了许多的函数和例程...
总结起来,多线程和线程池是提升程序并发能力的基础,而Fork/Join框架则是对多线程的一种高效利用,尤其适合解决可分割的问题。通过理解并掌握这些知识,开发者能够编写出更加高效、可扩展的并发程序。在实际开发中...
1. Thread 类:Thread 类是 Java 中的基本线程类,提供了创建和管理线程的方法。 2. Runnable 接口:Runnable 接口是 Java 中的基本线程接口,提供了线程的执行方法。 线程同步 Java 中的多线程编程需要解决线程...
总结,Qt5的多线程机制是通过QThread类实现的,它允许开发者创建独立的工作线程来处理后台任务,从而保持主线程的流畅性。`WorkThread`是一个很好的实践示例,展示了如何在Qt中自定义线程类并实现线程间的通信。正确...
Java并发包(java.util.concurrent)提供了许多高效且线程安全的工具类,如Semaphore(信号量)、CyclicBarrier(屏障)、CountDownLatch(计数器门锁)等,便于编写多线程程序。 通过理解和掌握以上知识点,...
### CoreJava多线程学习总结 #### 一、基本概念 多线程是现代软件开发中非常重要的一个概念,尤其在Java这样的高级编程语言中,它使得程序能够更高效地利用计算机资源,实现并发处理任务。为了更好地理解CoreJava...