并发工具类:CountDownLatch、CyclicBarrier、Semaphore

在多线程的场景下,有些并发流程需要人为来控制,在JDK的并发包里提供了几个并发工具类:CountDownLatch、CyclicBarrier、Semaphore。

一、CountDownLatch

 import java.util.concurrent.CountDownLatch;

 public class CountDownLatchTest
{
    //设置N为2
static CountDownLatch c = new CountDownLatch(2);
public static void main(String[] args) throws Exception
{
Thread t1 = new Thread(new Runnable()
{ @Override
public void run()
{
System.out.println("1");
           //将N减1
c.countDown();
}
}); Thread t2 = new Thread(new Runnable()
{ @Override
public void run()
{
System.out.println("2");
c.countDown();
}
});
t1.start();
t2.start();
      //让当前线程等待,直到计数N为0
c.await();
System.out.println("3");
}
}

执行结果:

1
2
3

这里会存在两种结果:123或者213,但是绝对不会出现3打印在1、2前面的。

new CountDownLatch(2);

这个CountDownLatch的构造函数接收一个int类型的参数作为计数器,N表示阻塞的线程必须等待N次countDown才能执行。

每次调用CountDownLatch的countDown方法时,N就会减1,而这个方法可以使用在任何地方,这里的N点可以是N个线程,也可以是一个线程中N个步骤。

而CountDownLatch的await方法则会阻塞当前线程,直到N为0的时候才能执行。

我们将上面的程序改造下,让线程中有两个打印动作,并且第二个动作前线程休眠一段时间:

 import java.util.concurrent.CountDownLatch;

 public class CountDownLatchTest
{
static CountDownLatch c = new CountDownLatch(2);
public static void main(String[] args) throws Exception
{
Thread t1 = new Thread(new Runnable()
{ @Override
public void run()
{
System.out.println("1");
c.countDown();
try
{
Thread.sleep(500);
System.out.println("2");
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}); Thread t2 = new Thread(new Runnable()
{ @Override
public void run()
{
System.out.println("3");
c.countDown();
}
});
t1.start();
t2.start();
c.await();
System.out.println("4");
}
}

执行结果:

1
3
4
2

这个结果是由于在打印完1、3之后,N已经变化为0,主线程执行打印4,由于线程1休眠,所以2最后才打印。

在上面的程序中,如果将N设置为3,则主线程中的打印4永远不会执行,因为没有N永远只会到1而不会减少到0.

在这里我们想起了线程的join方法,这个方法也是可以阻塞当前线程,等待某线程执行完成。通过对比,我们可以发现使用CountDownLatch这个工具类更灵活,因为countDown可以用在任何线程的任何地方。

CountDownLatch适合一个大任务拆分成多个小任务,然后在所有子任务完成后,通知其他的后续操作开始执行。

二、同步屏障CyclicBarrier

CyclicBarrier默认的构造方法CyclicBarrier(int parties),其参数表示屏障拦截的线程数量,每个线程调用await方法告诉CyclicBarrier我已经到达屏障,然后当前线程被阻塞,直到被拦截的线程全部都到达了屏障,然后前面被阻塞的线程才能开始执行,否则会被一直阻塞。

 public class CyclicBarrierTest
{
static CyclicBarrier c = new CyclicBarrier(3); public static void main(String[] args)
throws Throwable, BrokenBarrierException
{
Thread t1 = new Thread(new Runnable()
{
@Override
public void run()
{
try
{
c.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
catch (BrokenBarrierException e)
{
e.printStackTrace();
}
System.out.println("1"); }
});
Thread t2 = new Thread(new Runnable()
{
@Override
public void run()
{
try
{
c.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
catch (BrokenBarrierException e)
{
e.printStackTrace();
}
System.out.println("2");
}
}); t1.start();
t2.start();
c.await();
System.out.println("3");
}
}

执行结果:

3
1
2

上述中被屏障拦截的线程有3个,其中线程1和线程2执行的时候先到达屏障,然后被阻塞,主线程执行第52行到达屏障,至此阻塞的三个线程全部到达屏障,然后阻塞的线程可以去竞争CPU开始执行。

如果将拦截的线程数修改为4:

static CyclicBarrier c = new CyclicBarrier(4);

这样的话被拦截的线程数有4个,但是只有三个线程调用await方法告诉CyclicBarrier,我到达了屏障。所以这三个线程都会被阻塞。

另外还有一点就是CyclicBarrier的计数器可以重置,例如设置的是拦截线程数量为2,但是有3个线程调用了await()方法表示到达了屏障,这个时候会出现最先达到屏障的两个线程顺利执行完毕,而最后到达的第三个线程则一直被阻塞,因为它等不到另外一个线程到达屏障了。

而如果拦截线程的数量依旧为2,但是有4个线程调用了await()方法,那么这4个线程是分两批执行的,前两个线程满足拦截的线程数,到达屏障后放行;然后CyclicBarrier的计数器重置,后面两个线程到达屏障后放行。

 import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier; import sun.java2d.SunGraphicsEnvironment.T1Filter; public class CyclicBarrierTest
{
static CyclicBarrier c = new CyclicBarrier(2); public static void main(String[] args) throws Throwable, BrokenBarrierException
{
Thread t1 = new Thread(new Runnable()
{
@Override
public void run()
{
try
{
c.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
catch (BrokenBarrierException e)
{
e.printStackTrace();
}
System.out.println("1"); }
});
Thread t2 = new Thread(new Runnable()
{
@Override
public void run()
{
try
{
c.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
catch (BrokenBarrierException e)
{
e.printStackTrace();
}
System.out.println("2");
}
}); Thread t3 = new Thread(new Runnable()
{
@Override
public void run()
{
try
{
c.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
catch (BrokenBarrierException e)
{
e.printStackTrace();
}
System.out.println("3"); }
});
t1.start();
t2.start();
t3.start();
c.await();
System.out.println("4");
}
}

CyclicBarrier可以用于多线程计算数据,最后合并结果的场景;由于CyclicBarrier的计数器可以重置,所以可以使用它处理更为复杂的业务场景,而CountDownLatch计数器只能使用一次。

三、信号量Semaphore

无论是内部锁synchronized还是重入锁ReentrantLock,一次都只允许一个线程访问某一个资源,而信号量却可以指定多个线程同时访问某一资源;主要用来控制同时访问特定资源的线程数量,它通过协调各个线程,以保证合理的使用公共资源。

 public class SemaphoreTest implements Runnable
{
final Semaphore s = new Semaphore(5);
@Override
public void run()
{
try
{
s.acquire();
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " is done");
s.release();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
public class MainTest
{
public static void main(String[] args)
{
SemaphoreTest s = new SemaphoreTest();
//创建一个可重用固定线程数的线程池,线程数量为20
ExecutorService threadPool= Executors.newFixedThreadPool(20);
for(int i=0;i<20;i++)
{
threadPool.submit(s);
}
threadPool.shutdown();
}
}

执行的结果是每五个线程为一组打印消息。

线程池里面有20个可重复使用的线程数量,但是信号量只有5个,也就是每次只能并发5个线程执行,其他线程阻塞。

信号量为5,可以认为线程池里有5把锁,每个线程调用acquire和release分别表示获取锁和释放锁,这样,通过信号量就可以调度多个线程的执行。

上一篇:Python中byte与str


下一篇:vim 插件