多线程类总结

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()  //计数器减一

 

 

说一说java的concurrent包-系列文章

实战Concurrent

Java多线程同步机制（synchronized）

 

 

 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