当前位置:首页 > 开发 > 编程语言 > 多线程 > 正文

线程同步工具类

发表于: 2015-04-28   作者:shuizhaosi888   来源:转载   浏览:
摘要: 同步工具类包括信号量(Semaphore)、栅栏(barrier)、闭锁(CountDownLatch)   闭锁(CountDownLatch) public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin

同步工具类包括信号量(Semaphore)、栅栏(barrier)、闭锁(CountDownLatch)

 

闭锁(CountDownLatch)

public class RunMain {
	public long timeTasks(int nThreads, final Runnable task) throws InterruptedException {
		final CountDownLatch startGate = new CountDownLatch(1);
		final CountDownLatch endGate = new CountDownLatch(nThreads);

		for (int i = 0; i < nThreads; i++) {
			Thread t = new Thread() {
				public void run() {
					try {
						startGate.await();
						try {
							task.run();
						} finally {
							endGate.countDown();
						}
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

				};
			};
			t.start();
		}
		long start = System.nanoTime();
		startGate.countDown();
		endGate.await();
		long end = System.nanoTime();
		return end - start;
	}

}

 

FutrureTask

     FutureTask也可以做闭锁,FutureTask表示的计算是通过Callable来实现的,相当于一种可生成结果的Runnable,并且可以处于一下3中状态

  • 等待运行
  • 正在运行
  • 运行完成:表示计算的所有可能结束方式包括正常结束、由于取消而结束和由于异常而结束等。当FutureTask进入完成状态后,它会永远停止在这个状态上。

    Future.get的行为取决于任务的状态,如果任务已经完成,那么get会立即返回结果,否则将阻塞知道完成状态,然后返回结果或者抛出异常。FutureTask将计算结果从执行计算的线程传递到获取这个结果的线程,而FutureTask的规范确保了这种传递过程能实现结果的安全发布。

public class RunMain {

	private FutureTask<String> future = new FutureTask<String>(new Callable<String>() {
		public String call() throws Exception {
			System.err.println("数据加载中");
			Thread.sleep(3000);
			return "数据加载完成";
		};
	});

	private Thread thread = new Thread(future);

	public void start() {
		thread.start();
	}

	public String get() throws InterruptedException, ExecutionException {
			return future.get();
	}
	
	public static void main(String[] args) throws InterruptedException, ExecutionException{
		RunMain run  = new RunMain();
		run.start();
		System.out.println(run.get());
	}
}

 

信号量(Semaphore)

计数信号量用来控制同时访问某个特定资源的操作数量,或者同时执行某个制定操作的数量,计数信号量还可以用来实现某种资源池或者对容器施加边界

public class RunMain<T> {
	private Set<T> set;
	private Semaphore sem;

	public RunMain(int bound) {
		set = Collections.unmodifiableSet(new HashSet<T>());
		sem = new Semaphore(bound);
	}

	public boolean add(T t) throws InterruptedException {
		sem.acquire();
		boolean boo = false;
		try {
			boo = set.add(t);
			return boo;
		} finally {
			if (!boo)
				sem.release();
		}
	}

	public boolean remove(T t) {
		boolean boo = set.remove(t);
		if (boo)
			sem.release();
		return boo;

	}
}

 

栅栏(barrier) 

 所有线程必须同时到达栅栏的位置,才能继续执行,闭锁用于等待事件,而栅栏用于等待其他线程。

CyclicBarrier可以使一定数量的参与方反复地在栅栏位置聚集,它在并行迭代算法中非常有用。

代码摘自:http://www.cnblogs.com/dolphin0520/p/3920397.html

public class Test {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程"+Thread.currentThread().getName());   
            }
        });
         
        for(int i=0;i<N;i++)
            new Writer(barrier).start();
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕,等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕,继续处理其他任务...");
        }
    }
}

 

 

线程同步工具类

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
CountDownLatch 犹如倒计时计数器,调用CountDownLatch对象的countDown方法就将计数器减1,当计数到
CyclicBarrier一个同步辅助类。 它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier
Exchanger 用于实现两个人之间的数据交换,每个人在完成一定的事务后想与对方交换数据,第一个先拿
package com.entel.research; import java.util.concurrent.CyclicBarrier; import java.util.concu
1.新知识普及 2. Semaphore工具类的使用案例 package com.java5.thread.newSkill; import java.util
1. 设计背景 在设计多线程程序的时候,时常会遇到对同一个数据进行读写操作的情况。为了保证多线程
允许一系列的集合等待彼此,到达一个共同的障碍物点. 表示大家彼此等待,大家集合好后才开始出发,分散
详细代码如下: public class CountdownLatchTest { public static void main(String[] args) { Exec
代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; us
目录: 一、线程同步概述 二、线程同步的使用 三 、总结 一、线程同步概述 前面的文章都是讲创建多
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号