Java多线程实现

来源：互联网发布：前端网页ajax获取数据编辑：程序博客网时间：2024/06/07 03:15

PART.1 通过Thread实现多线程

1. Thread

getID()

获取线程ID。

getName(), setName()

获取和设置线程名。

getPriority(), setPriority()

获取和设置线程优先级。

getState()

获取线程状态。

getThreadGroup()

获取线程所在的线程组。

isAlive()

获取线程是否已经启动并且没有终止。

isDaemon(), setDaemon()

获取和设置线程是否为守护线程。

isInterrupted()

获取线程是否被中断。

start()

开始线程。

join()

等待指定线程中终止。

interrupt()

中断线程

静态方法

currentThread()

获取当前线程。

sleep()

使当前线程休眠指定的时间。

yield()

使当前线程暂停执行，让其它等待的线程执行。

interrupted()

获取当前线程是否被中断。

2. 通过Thread实现多线程

1. 通过继承Thread类并覆盖Thread的run()方法创建一个新的线程类。

2. 使用该线程类创建线程对象。

public class ThreadTest
{
public static void main(String[] args) throws Exception
{
TestThread th = new TestThread("thread 1");
th.start();
th.join();
System.out.println("'main' ended.");
}
private static class TestThread extends Thread
{
public TestThread(String threadName)
{
super(threadName);
}
@Override
public void run()
{
String thName = Thread.currentThread().getName();
System.out.printf("'%s' started. /n", thName);
for (int i = 0; i < 10; i++)
{
System.out.println(i);
}
System.out.printf("'%s' ended. /n", thName);
}
}
}

3. 通过Runnable实现多线程

1. 创建一个Runnable接口的实现类（实现run()方法）。

2. 通过Thread类包含Runnable的构造方法创建线程对象。

Thread(Runnable target)

Thread(ThreadGroup group, Runnable target)

ThreadGroup group, Runnable target, String name)

public class RunnableTest
{
public static void main(String[] args) throws Exception
{
Thread th = new Thread(new TestRunnable(), "thread 1");
th.start();
th.join();
System.out.println("'main' ended.");
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
String thName = Thread.currentThread().getName();
System.out.printf("'%s' started. /n", thName);
for (int i = 0; i < 10; i++)
{
System.out.println(i);
}
System.out.printf("'%s' ended. /n", thName);
}
}
}

4. ThreadGroup

activeCount()

获取线程组中正在执行的线程数量。

activeGroupCount()

获取线程组中正在执行的线程组数量。

getMaxPriority(), setMaxPriority()

获取和设置最大优先级

getName()

获取线程组的名称。

getParent()

获取父线程组

interrupt()

中断线程组中的所有线程。

isDaemon(), setDaemon()

获取和设置线程组是否为守护线程。

parentOf(ThreadGroup)

判断线程组是否包含于指定线程组中。

5. 通过ThreadGroup管理线程

在创建线程对象时，通过包含ThreadGroup的构造方法创建，将线程加入指定线程组

Thread(ThreadGroup group, Runnable target)

Thread(ThreadGroup group, Runnable target, String name)

Thread(ThreadGroup group, String name)

public class ThreadGroupTest
{
public static void main(String[] args) throws Exception
{
// 创建线程组对象。
ThreadGroup tg = new ThreadGroup("group 1");
// 向线程组中加入10个线程。
for (int i = 0; i < 10; i++)
{
Thread th = new Thread(tg, new TestRunnable(), "thread " + i);
th.start();
}
// 等待2秒。
Thread.sleep(2000);
// 中断所有线程。
tg.interrupt();
// 输出
System.out.println(tg.activeCount());
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
String thName = Thread.currentThread().getName();
System.out.printf("'%s' started. /n", thName);
while (!Thread.currentThread().isInterrupted())
{
}
System.out.printf("'%s' ended. /n", thName);
}
}
}

PART.2 通过Callable和FutureTask实现异步调用

1. Callable<V>

Ø V为返回值的类型。

Ø 实现Callable接口需实现call方法。

Ø 与Runnable的run方法相比，call方法具有返回值V和异常声明。

2. FutureTask<V>

V为返回值得类型。

cancel()

取消执行。

get()

阻塞获取执行结果。

get(long, TimeUnit)

指定阻塞的最长时间，获取执行结果。

isCancelled()

获取是否被取消。

isDone()

获取是否完成。

run()

开始执行。

3. 通过Callable和FutureTask异步执行

1. 创建一个Callable<V>的实现类。

2. 创建FutureTask<V>对象。

3. 执行创建的FutureTask对象。(run方法)

4. 通过FutureTask对象获取结果。(get方法)

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class FutureTaskTest
{
public static void main(String[] args)
{
FutureTask<Integer> ct = null;
ct = new FutureTask<Integer>(new TestCallable());
ct.run();
try
{
int ret = ct.get();
System.out.println(ret);
}
catch (InterruptedException e)
{
// ct.get() 时线程被中断。
e.printStackTrace();
}
catch (ExecutionException e)
{
// Callable在执行时出现异常。
e.printStackTrace();
}
}
private static class TestCallable implements Callable<Integer>
{
@Override
public Integer call() throws Exception
{
double i = Math.random() * 100;
return (int)i;
}
}
}

4．处理FutureTask执行时发生的异常

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class FutureTaskExceptionTest
{
public static void main(String[] args)
{
FutureTask<Integer> ct = null;
ct = new FutureTask<Integer>(new TestCallable());
ct.run();
try
{
int ret = ct.get();
System.out.println(ret);
}
catch (InterruptedException e)
{
// ct.get() 时线程被中断。
e.printStackTrace();
}
catch (ExecutionException e)
{
// Callable在执行时出现异常。
System.out.println(e.getCause().getMessage());
System.out.println(e.getMessage());
}
}
private static class TestCallable implements Callable<Integer>
{
@Override
public Integer call() throws Exception
{
throw new Exception("An test exception.");
}
}
}

PART.3 通过ExecutorService实现多线程

1. ExecutorService

awaitTermination

等待所有任务结束。

invokeAll

执行集合中的所有任务，返回所有Future。该方法将等待所有任务结束或指定的时间。

invokeAny

执行集合中的一个任务，返回该任务得返回值。

isShutdown

获取ExecutorService是否被shutdown。

isTerminated

获取是否所有任务已经结束。

Shutdown

等待所有正在执行的任务结束。将没有执行的任务返回。不执行后新的任务。

shutdownNow

中断正在执行的任务。返回没有执行的任务。

submit

提交一个任务并开始执行。

2. 创建ExecutorService

Executors.newCachedThreadPool

Executors.newFixedThreadPool

Executors.newScheduledThreadPool

Executors.newSingleThreadExecutor

Executors.newSingleThreadScheduledExecutor

3. 通过ExecutorService实现多线程

1. 创建ExecutorService对象。

2. 向ExecutorServices对象提交任务。

3. 获得结果。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ExecutorServiceTest
{
public static void main(String[] args) throws Exception
{
ExecutorService es = Executors.newCachedThreadPool();
// 创建10个任务，将这些任务交由ExecutorService执行，保存这些任务的Future到List。
List<Future<Integer>> fs = new ArrayList<Future<Integer>>(10);
for (int i = 0; i < 10; i++)
{
TestCallable t = new TestCallable();
Future<Integer> f = es.submit(t);
fs.add(f);
}
// 等待执行结束。
Thread.sleep(1000);
// 输出执行结果。
for (Future<Integer> f : fs)
{
System.out.println(f.get());
}
// 关闭ExecutorService。
es.shutdown();
}
private static class TestCallable implements Callable<Integer>
{
@Override
public Integer call() throws Exception
{
double ret = Math.random() * 100;
return (int)ret;
}
}
}

4. 关闭ExecutorService

shutdown() 等待任务结束

shutdownNow() 中断任务

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorServiceShutdownTest
{
public static void main(String[] args) throws Exception
{
// PART 1 测试shutdownNow()。
System.out.println("----- PART 1");
// 创建ExecutorService。
ExecutorService es = Executors.newCachedThreadPool();
// 开始10个任务。
System.out.println("----- Start all tasks...");
for (int i = 0; i < 10; i++)
{
TestCallable task = new TestCallable("task " + i);
es.submit(task);
}
// 等待5秒。在此期间可能有任务结束。
System.out.println("----- Wait for 5 seconds.");
Thread.sleep(5000);
// 结束所有任务。
System.out.println("----- Shutdown all tasks now.");
es.shutdownNow();
System.out.println("----- End of PART 1");
Thread.sleep(1000);
// 测试shutdown()。
System.out.println("----- PART 2");
Thread.sleep(1000);
// 创建ExecutorService。
es = Executors.newCachedThreadPool();
// 开始10个任务。
System.out.println("----- Start all tasks...");
for (int i = 0; i < 10; i++)
{
TestCallable task = new TestCallable("task " + i);
es.submit(task);
}
// 等待5秒。在此期间可能有任务结束。
System.out.println("----- Wait for 5 seconds.");
Thread.sleep(5000);
// 结束所有任务。
System.out.println("----- Shutdown all tasks.");
es.shutdown();
System.out.println("----- End of main.");
}
private static class TestCallable implements Callable<Void>
{
private String name;
public TestCallable(String name)
{
this.name = name;
}
@Override
public Void call() throws Exception
{
System.out.printf("'%s' started. /n", name);
// 等待3 - 12秒。
try
{
int w = (int)(Math.random() * 10 + 3);
Thread.sleep(w*1000);
}
catch (InterruptedException e)
{
System.out.printf("'%s' interrupted. /n", name);
}
System.out.printf("'%s' ended. /n", name);
return null;
}
}
}

Java线程同步

PART.1 ReentrantLock

1. 通过ReentrantLock的lock和unlock方法获得和释放锁。

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockTest
{
private static ReentrantLock locker = new ReentrantLock();
public static void main(String[] args) throws Exception
{
Thread th = new Thread(new TestRunnable());
System.out.println("main: lock.");
locker.lock();
System.out.println("main: starting Test.");
th.start();
System.out.println("main: sleep for 3 seconds.");
Thread.sleep(3000);
System.out.println("main: unlock.");
locker.unlock();
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
System.out.println("test: start and lock.");
locker.lock();
System.out.println("test: between lock and unlock.");
locker.unlock();
System.out.println("test: end.");
}
}
}

2．2个线程分别向counter加10，每次加1。

import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockTest2
{
private static ReentrantLock locker = new ReentrantLock();
private static int counter = 0;
public static void main(String[] args) throws Exception
{
Thread th1 = new Thread(new TestRunnable());
Thread th2 = new Thread(new TestRunnable());
th1.start();
th2.start();
th1.join();
th2.join();
System.out.println(counter);
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
for (int i = 0; i < 10; i++)
{
locker.lock();
try
{
int temp = counter + 1;
Thread.sleep(100);
counter = temp;
}
catch (InterruptedException e)
{
return;
}
finally
{
locker.unlock();
}
}
}
}
}

PART.2 Condition

1. 通过ReentrantLock创建Condition对象

2. 在获得锁的条件下，调用Condition的await方法释放锁并等待其他线程调用同一Condition对象的signal方法。

3. 另一线程在获得锁的条件下调用Condition对象的signal方法。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionTest
{
private static ReentrantLock locker = null;
private static Condition condition = null;
public static void main(String[] args) throws Exception
{
locker = new ReentrantLock();
condition = locker.newCondition();
Thread th = new Thread(new TestRunnable());
th.start();
Thread.sleep(3000);
System.out.println("main: signal all.");
// 调用condition.signalAll()将使Test线程中的阻塞结束。
locker.lock();
condition.signalAll();
locker.unlock();
System.out.println("main: end.");
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
locker.lock();
try
{
System.out.println("test: before 'condition.await()'");
// await()将阻塞直到其他线程调用condition.signal。
condition.await();
System.out.println("test: after 'condition.await()'");
Thread.sleep(1000);
}
catch (InterruptedException e)
{
}
finally
{
locker.unlock();
}
}
}
}

生产者与消费者示例

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionTest2
{
private static ReentrantLock locker;
private static Condition condition;
private static Queue<Integer> queue;
public static void main(String[] args) throws Exception
{
locker = new ReentrantLock();
condition = locker.newCondition();
queue = new LinkedList<Integer>();
Thread pth = new ProducerThread();
Thread cth = new ConsumerThread();
pth.start();
cth.start();
Thread.sleep(30 * 1000);
pth.interrupt();
cth.interrupt();
pth.join();
cth.join();
}
private static class ProducerThread extends Thread
{
@Override
public void run()
{
// 每0-500毫秒产生一个随机整数并加入队列。
while (!Thread.currentThread().isInterrupted())
{
locker.lock();
try
{
int x = (int)(Math.random() * 100);
queue.offer(x);
condition.signalAll();
System.out.println("producer: " + x + ", signal all");
// 随机休眠0-499毫秒
Thread.sleep((int)(Math.random() * 500));
}
catch (InterruptedException e)
{
break;
}
finally
{
locker.unlock();
}
}
System.out.println("End of ProducerThread.");
}
}
private static class ConsumerThread extends Thread
{
@Override
public void run()
{
// 每0-500毫秒从队列取出一个数并输出。
while (!Thread.currentThread().isInterrupted())
{
locker.lock();
try
{
// 如果队列为空，将等待ProducerThread向队列插入数据。
while (queue.isEmpty())
{
System.out.println("consumer: Queue is empty.");
condition.await();
}
int x = queue.poll();
System.out.println("consumer: " + x);
// 随机休眠0-499毫秒
Thread.sleep((int)(Math.random() * 500));
}
catch (InterruptedException e)
{
break;
}
finally
{
locker.unlock();
}
}
System.out.println("End of ComsumerThread.");
}
}
}

CyclicBarrier用于设置一个Barrier，达到Barrier的线程将等待，当所有线程都达到Barrier时，所有线程继续执行。

1. 创建CyclicBarrier时通过构造函数指定线程的数量n。

2. 每个线程调用await方法等待其他线程。

3. 当有n个await方法被调用时，所有处于await的线程都将继续执行。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierTest
{
private static CyclicBarrier barrier = null;
public static void main(String[] args)
{
// 初始化
barrier = new CyclicBarrier(10);
// 启动10个线程
System.out.println("main: starting 10 threads.");
for (int i = 0; i < 10; i++)
{
Thread th = new Thread(new TestRunnable(), "thread " + i);
th.start();
}
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
String thName = Thread.currentThread().getName();
try
{
// 随机等待5-14秒
int n = (int)(Math.random() * 10 + 5);
System.out.printf("%s: sleep for %d seconds. /n", thName, n);
Thread.sleep(n * 1000);
// 等待其他线程
System.out.printf("%s: waiting for other threads. /n", thName);
barrier.await();
// 结束
System.out.printf("%s: end. /n", thName);
}
catch (InterruptedException e)
{
System.out.printf("%s: interrupted. /n", thName);
return;
}
catch (BrokenBarrierException e)
{
System.out.printf("%s: broken barrier. /n", thName);
return;
}
}
}
}

1. 在调用await方法时设置超时时间。

2. 当有一个await方法超时，所有处于await等待的线程将收到BrokenBarrierException，超时的线程自身将收到TimeoutException。

3. BrokenBarrier之后的所有await调用将直接抛出BrokenBarrierException。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class CyclicBarrierBrokenTest
{
private static CyclicBarrier barrier = null;
public static void main(String[] args)
{
// 初始化
barrier = new CyclicBarrier(10);
// 启动10个线程
System.out.println("main: starting 10 threads.");
for (int i = 0; i < 10; i++)
{
Thread th = new Thread(new TestRunnable(), "thread " + i);
th.start();
}
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
String thName = Thread.currentThread().getName();
try
{
// 随机等待5-14秒
int n = (int)(Math.random() * 10 + 5);
System.out.printf("%s: sleep for %d seconds. /n", thName, n);
Thread.sleep(n * 1000);
// 等待其他线程
System.out.printf("%s: waiting for other threads. /n", thName);
barrier.await(5, TimeUnit.SECONDS);
// 结束
System.out.printf("%s: end. /n", thName);
}
catch (InterruptedException e)
{
System.out.printf("%s: interrupted. /n", thName);
return;
}
catch (BrokenBarrierException e)
{
System.out.printf("%s: broken barrier. /n", thName);
return;
}
catch (TimeoutException e)
{
System.out.printf("%s: timeout. /n", thName);
return;
}
}
}
}

当调用await线程达到CyclicBarrier的设置之后，CyclicBarrier将被重置，重新等待n个await调用。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierResetTest
{
private static CyclicBarrier barrier = null;
public static void main(String[] args) throws Exception
{
barrier = new CyclicBarrier(2);
Thread th1 = new Thread(new TestRunnable(), "thread 1");
Thread th2 = new Thread(new TestRunnable(), "thread 2");
th1.start();
th2.start();
Thread.sleep(60 * 1000);
th1.interrupt();
th2.interrupt();
th1.join();
th2.join();
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
String thName = Thread.currentThread().getName();
System.out.printf("%s: start. /n", thName);
try
{
while (true)
{
// 随机产生1-100的整数。
int c = (int)(Math.random() * 100) + 1;
// 随机等待0-4秒。
int t = (int)(Math.random() * 5);
System.out.printf("%s: sleep for %d seconds./n", thName, t);
Thread.sleep(t * 1000);
// 等待另1线程。
barrier.await();
// 输出产生的整数。
System.out.printf("%s: %d /n", thName, c);
// 等待其他线程输出。
Thread.sleep(100);
}
}
catch (InterruptedException e)
{
System.out.printf("%s: interrupted. /n", thName);
}
catch (BrokenBarrierException e)
{
e.printStackTrace();
}
System.out.printf("%s: end. /n", thName);
}
}
}

1. 在创建CyclicBarrier的时候指定通过Barrier时需要执行的语句。

2. 通过构造方法的Runnable参数指定。

3. Runnable中的语句将由最后达到Barrier的线程执行。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierActionTest
{
private static CyclicBarrier barrier = null;
public static void main(String[] args) throws Exception
{
barrier = new CyclicBarrier(10, new BarrierAction());
for (int i = 0; i < 10; i++)
{
Thread th = new Thread(new TestRunnable(), "thread " + i);
th.start();
}
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
try
{
String thName = Thread.currentThread().getName();
// System.out.printf("%s: start. /n", thName);
// 随机等待0-9秒
int t = (int)(Math.random() * 10);
System.out.printf("%s: sleep for %d seconds. /n", thName, t);
Thread.sleep(t * 1000);
// 等待barrier
barrier.await();
System.out.printf("%s: end. /n", thName);
}
catch (InterruptedException e)
{
e.printStackTrace();
return;
}
catch (BrokenBarrierException e)
{
e.printStackTrace();
return;
}
}
}
private static class BarrierAction implements Runnable
{
@Override
public void run()
{
String thName = Thread.currentThread().getName();
System.out.printf("%s: barrier action. /n", thName);
}
}
}

1. CountDownLatch

CountDownLatch用于等待计数器计数。
在创建CountDownLatch时指定初始的整数。
调用CountDownLatch的await方法等待计数器到0。
每调用一次CountDownLatch的countDown方法，计数器减1。

import java.util.concurrent.CountDownLatch;
public class CountDownLatchTest
{
    private static CountDownLatch counter = null;
    public static void main(String[] args) throws Exception
    {
        counter = new CountDownLatch(10);
        Thread th1 = new Thread(new TestRunnable(), "thread 1");
        Thread th2 = new Thread(new TestRunnable(), "thread 2");
        th1.start();
        th2.start();
        counter.await();
        System.out.println("main: after counter.await().");
        th1.interrupt();
        th2.interrupt();
        th1.join();
        th2.join();
        System.out.println("main: end.");
    }
    private static class TestRunnable implements Runnable
    {
        @Override
        public void run()
        {
            String thName = Thread.currentThread().getName();
            System.out.printf("%s: start. /n", thName);
            try
            {
                while (true)
                {
                    // 随机等待1-5秒
                    int t = (int) (Math.random() * 5 + 1);
                    System.out.printf("%s: sleep for %d seconds./n", thName, t);
                    Thread.sleep(1000 * t);
                    // 计数
                    counter.countDown();
                }
            }
            catch (InterruptedException e)
            {
                System.out.printf("%s: interrupted. /n", thName);
            }
            System.out.printf("%s: end. /n", thName);
        }
    }
}

2. Exchanger

Exchanger用于在2个线程中交换对象。
an_object = exchanger.exchange(an_object)
例子中Producer向ArrayList中缓慢填充随机整数，Consumer从另一个ArrayList中缓慢取出整数并输出。
当Producer的ArrayList填满，并且Consumer的ArrayList为空时，2个线程交换ArrayList。

import java.util.ArrayList;
import java.util.concurrent.Exchanger;
public class ExchangerTest
{
    private static Exchanger<ArrayList<Integer>> exchanger = null;
    private static ArrayList<Integer> buffer1 = null;
    private static ArrayList<Integer> buffer2 = null;
    public static void main(String[] args) throws Exception
    {
        exchanger = new Exchanger<ArrayList<Integer>>();
        buffer1 = new ArrayList<Integer>(10);
        buffer2 = new ArrayList<Integer>(10);
        Thread pth = new ProducerThread();
        Thread cth = new ConsumerThread();
        pth.start();
        cth.start();
        Thread.sleep(60 * 1000);
        System.out.println("main: interrupting threads.");
        pth.interrupt();
        cth.interrupt();
        pth.join();
        cth.join();
        System.out.println("main: end.");
    }
    private static class ProducerThread extends Thread
    {
        @Override
        public void run()
        {
            ArrayList<Integer> buff = buffer1;
            try
            {
                while (true)
                {
                    if (buff.size() >= 10)
                    {
                        // 与consumer交换buffer.
                        System.out.println("producer: exchanging.");
                        buff = exchanger.exchange(buff);
                        buff.clear();
                    }
                    // 随机产生一个0-100的整数。
                    int x = (int) (Math.random() * 100);
                    buff.add(x);
                    System.out.println("producer: " + x);
                    // 随机等待0-3秒 。
                    int t = (int) (Math.random() * 3);
                    Thread.sleep(t * 1000);
                }
            }
            catch (InterruptedException e)
            {
                System.out.println("producer: interrupted.");
            }
        }
    }
    private static class ConsumerThread extends Thread
    {
        @Override
        public void run()
        {
            ArrayList<Integer> buff = buffer2;
            try
            {
                while (true)
                {
                    for (Integer x : buff)
                    {
                        System.out.println("consumer: " + x);
                        // 随机等待0-3秒 。
                        int t = (int) (Math.random() * 3);
                        Thread.sleep(t * 1000);
                    }
                    // 与producer交换buffer。
                    System.out.println("consumer: exchanging.");
                    buff = exchanger.exchange(buff);
                }
            }
            catch (InterruptedException e)
            {
                System.out.println("consumer: interrupted.");
            }
        }
    }
}

3. Semaphore

Semaphore对象保存n个许可。（在构造方法指定）
一个线程可以从Semahpore中取出x个许可，当Semaphore对象中的许可数量不足x时将阻塞。
线程使用完许可后将许可归还给Semaphore。

import java.util.ArrayList;
import java.util.concurrent.Semaphore;
public class SemaphoreTest
{
    private static Semaphore semaphore = null;
    private static ArrayList<TestThread> threads = null;;
    private static ThreadGroup group = null;
    public static void main(String[] args) throws Exception
    {
        semaphore = new Semaphore(10);
        threads = new ArrayList<TestThread>(5);
        group = new ThreadGroup("no name");
        for (int i = 0; i < 5; i++)
        {
            TestThread th = new TestThread("thread " + i, group);
            threads.add(th);
            th.start();
        }
        for (int i = 0; i < 60; i++)
        {
            System.out.println(i + " :/t" + getStatus());
            Thread.sleep(1000);
        }
        group.interrupt();
    }
    private static String getStatus()
    {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 5; i++)
        {
            sb.append(threads.get(i).getStatus());
            sb.append("/t");
        }
        sb.append(":");
        sb.append(10 - semaphore.availablePermits());
        return sb.toString();
    }
    private static class TestThread extends Thread
    {
        private String status = "";
        public String getStatus()
        {
            return status;
        }
        public TestThread(String name, ThreadGroup group)
        {
            super(group, name);
        }
        @Override
        public void run()
        {
            String thName = Thread.currentThread().getName();
            System.out.printf("%s: started. /n", thName);
            try
            {
                while (true)
                {
                    int p = (int) (Math.random() * 4) + 1;
                    status = "[" + p + "]";
                    semaphore.acquire(p);
                    status = " " + p + " ";
                    Thread.sleep((long) (Math.random() * 3000) + 2000);
                    semaphore.release(p);
                }
            }
            catch (InterruptedException e)
            {
                System.out.printf("%s: interrupted. /n", thName);
            }
        }
    }
} 

Java 可中断线程

PART.1 无法中断的线程

一个无法中断的线程的例子。

public class UninterruptableThread
{
@SuppressWarnings("deprecation")
public static void main(String[] args) throws Exception
{
Thread th = new Thread(new TestRunnable());
// 启动线程
System.out.println("main: start thread.");
th.start();
// 等待2秒
Thread.sleep(2000);
// 中断线程
System.out.println("main: interrupt thread.");
th.interrupt();
// 等待2秒
Thread.sleep(2000);
// 停止线程
System.out.println("main: stop thread.");
th.stop();
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
System.out.println("Thread started.");
while (true)
{
// 避免由于while(true)导致编译失败。
if (false) break;
}
// 清理工作
System.out.println("Thread ended.");
}
}
}

输出结果：

main: start thread.
Thread started.
main: interrupt thread.
main: stop thread.

Thread对象的interrupt方法仅仅把该线程的一个标志置为true，该方法本身并不包含任何中断线程的操作。
stop方法可以将线程中止，但通过输出的结果可以发现，”Thread ended”并没有被输出，即线程本身不能进行任何清理工作。

PART.2 可中断的线程

线程应不断检查isInterrupted是否为true，当其返回true时，应开始清理并结束线程。（Test1中的while循环）
Thread.sleep方法会在线程被中断时抛出InterruptedException，线程可以捕获该异常并开始清理和结束线程。（Test2中的Thread.sleep()）
如果循环中不时调用Thread.sleep，可以处理isInterrupted。

可中断线程的例子：

public class GeneralTest
{
public static void main(String[] args) throws Exception
{
Thread th1 = new Thread(new Test1());
Thread th2 = new Thread(new Test2());
// 启动 Test1 和 Test2 线程。
System.out.println("main: starting 'Test1' and 'Test2'.");
th1.start();
th2.start();
// 等待3秒。
System.out.println("main: sleeping for 3 seconds.");
Thread.sleep(3000);
// 中断 Test1 和 Test2 线程。
System.out.println("main: interrupting 'Test1' and 'Test2'.");
th1.interrupt();
th2.interrupt();
// 等待 Test1 和 Test2 线程结束。
System.out.println("main: waiting for 'Test1' and 'Test2' to end.");
th1.join();
th2.join();
System.out.println("main: end.");
}
private static class Test1 implements Runnable
{
@Override
public void run()
{
System.out.println("Test1: start.");
while (!Thread.currentThread().isInterrupted())
{
// 其他操作...
System.out.print("");
}
System.out.println("Test1: end.");
}
}
private static class Test2 implements Runnable
{
@Override
public void run()
{
System.out.println("Test2: start.");
try
{
while (true)
{
// 其他操作...
Thread.sleep(1000);
}
}
catch (InterruptedException e)
{
System.out.println("Test2: InterruptedException");
}
System.out.println("Test2: end.");
}
}
}

PART.3 isInterrupted()和interrputed()方法的区别

isInterrupted方法是实例方法，interrupted方法是静态方法。

Thread.currentThread().isInterrupted()
Thread.interrupted()

interrupted方法在调用之后会将中断标志置为false。在只对线程调用一次interrupt的前提下interrupted方法只会返回一次true。
使用interrupted方法判断应确保在判断之后开始结束线程。

isInterrupted和interrupted方法比较的例子：

public class InterruptedStateTest
{
public static void main(String[] args) throws Exception
{
// "Test1"
Thread th1 = new Thread(new Test1());
// 启动 Test1 线程，并在3秒之后中断该线程。
th1.start();
Thread.yield();
System.out.println("Test1 started... Waiting 3 seconds.");
Thread.sleep(3000);
System.out.println("Interrupting Test1...");
th1.interrupt();
Thread.sleep(1000);
System.out.println("---------------------------------------");
// “Test2"
Thread th2 = new Thread(new Test2());
// 启动 Test2 线程，并在3秒之后中断该线程。
th2.start();
Thread.yield();
System.out.println("Test2 started... Waiting 3 seconds.");
Thread.sleep(3000);
System.out.println("Interrupting Test2...");
th2.interrupt();
Thread.yield();
// 主线程结束。
System.out.println("End of main.");
}
private static class Test1 implements Runnable
{
@Override
public void run()
{
System.out.println("Test1 start...");
while (true)
{
if (Thread.currentThread().isInterrupted())
{
if (Thread.currentThread().isInterrupted())
{
System.out.println("Interrupted...");
break;
}
}
}
System.out.println("Test1 end...");
}
}
private static class Test2 implements Runnable
{
@Override
public void run()
{
// 记录线程开始时间。
long startTime = System.currentTimeMillis();
System.out.println("Test2 start... " +
"Automatically ends in 6 sec.");
while (true)
{
// 连续判断2次Thread.interrupted()
if (Thread.interrupted())
{
if (Thread.interrupted())
{
System.out.println("Interrupted...");
break;
}
}
// 如果线程2运行超过6秒将自动结束。
if (System.currentTimeMillis() - startTime > 6000 )
{
System.out.println("5 seconds...");
break;
}
}
System.out.println("Test2 end");
}
}
}

例子中Test1连续判断2次Thread.currentThread().isInterrupted()， Test1仍然可以正常中断。

if (Thread.currentThread().isInterrupted())
{
if (Thread.currentThread().isInterrupted())
{
// 结束线程。
}
}

Test2连续判断2次Thread.interrupted()，因此Test2线程在被调用interrupt之后没有结束。

if (Thread.interrupted())
{
if (Thread.interrupted())
{
// 结束线程。
}
}

PART.4 处理阻塞

阻塞操作如BufferedReader的readLine方法，ServerSocket的accept方法将导致线程不能判断isInterrupted()，因此线程中的阻塞不能永久阻塞。处理阻塞的方法有以下：

在调用阻塞方法时设置超时时间：

类

方法

超时后的处理

ReentrantLock

ReadLock

WriteLock

tryLock(long, TimeUnit)

返回false

Condition

await(long, TimeUnit)

awaitNanos(long)

awaitUntil(Date)

返回false

Future

get(long, TimeUnit)

TimeoutException

CyclicBarrier

await(long, TimeUnit)

TimeoutException

CountDownLatch

await(long, TimeUnit)

返回false

Exchanger

exchange(V, long, TimeUnit)

TimeoutException

Semaphore

tryAcquire(long, TimeUnit)

返回false

BlockingQueue<E>

offer(E, long, TimeUnit)

poll(long, TimeUnit)

返回false

返回null

BlockingDeque<E>

offerFirst(E, long, TimeUnit)

offerLast(E, long, TimeUnit)

poolFirst(long, TimeUnit)

poolLast(long, TimeUnit)

返回false

返回null

ServerSocket

accept()

通过setSoTimeout设置超时时间。

SocketTimeoutException

该方法在阻塞时如果线程被中断，可以抛出一个异常：

类

方法

异常

Thread

sleep(long)

join()

InterruptedException

ReentrantLock

ReadLock

WriteLock

lockInterruptibly()

InterruptedException

Condition

await()

InterruptedException

Future

get()

InterruptedException

CyclicBarrier

await()

InterruptedException

CountDownLatch

await()

InterruptedException

Exchanger

exchange(V)

InterruptedException

Semaphore

acquire()

InterruptedException

BlockingQueue<E>

put(E)

take()

InterruptedException

BlockingDeque<E>

putFirst(E)

putLast(E)

takeFirst(E)

takeLast(E)

InterruptedException

调用不可中断阻塞方法的可中断版本：

类

阻塞方法

可中断方法

ReentrantLock

ReadLock

WriteLock

lock()

tryLock()

tryLock(long, TimeUnit)

lockInterruptibly()

Condition

awaitUninterruptibly()

await()

await(long, TimeUnit)

awaitNanos(long)

awaitUntil(Date)

Semaphore

acquireUninterruptibly()

acquire()

tryAcquire()

tryAcquire(long, TimeUnit)

不能设置超时也不能抛出异常的阻塞方法：

synchronized块，Object的wait方法。可以使用ReentrantLock和Condition替代。
BufferedReader的readLine方法，ObjectInputStream得readObject方法。（如果底层流是通过Socket获得，可以通过Socket设置超时）

PART.5 处理Thread.sleep()

1. 捕获异常并结束线程

捕获InterruptedException异常，开始清理操作并结束线程。

public void run()
{
try
{
while (true)
{
// 需要进行的操作
Thread.sleep(500);
}
}
catch (InterruptedException e)
{
}
// 清理操作
}

2. 捕获异常，再次调用interrupt

public void run()
{
while (!Thread.currentThread().isInterrupted())
{
try
{
// 需要进行的操作 1
Thread.sleep(500);
}
catch (InterruptedException e)
{
// 再次调用interrupt
Thread.currentThread().interrupt();
}
try
{
// 需要进行的操作 2
Thread.sleep(500);
}
catch (InterruptedException e)
{
// 再次调用interrupt
Thread.currentThread().interrupt();
}
}
// 清理操作
}

PART.6 处理ReentrantLock和Condition

1. 通过lockInterruptibly方法中断

捕获lockInterruptibly方法可能跑出的InterruptedException，并结束线程。

public void run()
{
try
{
while (true)
{
locker.lockInterruptibly();
// 其他操作
locker.unlock();
}
}
catch (InterruptedException e)
{
}
// 清理操作
}

2. 通过不设置超时的tryLock方法中断

tryLock方法将不阻塞。
通过捕获Thread.sleep的异常（或其他方法）中断线程。

public void run()
{
try
{
while (true)
{
if (locker.tryLock())
{
// 其他操作
}
Thread.sleep(500);
}
}
catch (InterruptedException e)
{
}
}

3. 通过设置超时的tryLock方法中断

捕获tryLock方法在线程中断时抛出的InterrupedException并结束线程。

public void run()
{
try
{
while (true)
{
if (locker.tryLock(1, TimeUnit.SECONDS))
{
// 其他操作
}
}
}
catch (InterruptedException e)
{
}
// 清理操作
}

4. 通过捕获Conditon的await方法抛出的异常中断

捕获Condition的await方法抛出的异常并结束线程。

public void run()
{
try
{
while (true)
{
locker.lockInterruptibly();
condition.await();
// 其他操作
locker.unlock();
}
}
catch (InterruptedException e)
{
}
// 清理操作
}

5. 可中断的Producer和Consumer示例

produce方法在线程中断时将跑出InterruptedException。
run方法捕获该异常，并中断线程。

public void run()
{
try
{
while (true)
{
produce();
Thread.sleep((int)(Math.random() * 3000));
}
}
catch (InterruptedException e)
{
}
System.out.println("producer: end.");
}
private void produce() throws InterruptedException
{
locker.lockInterruptibly();
try
{
// Produce
int x = (int)(Math.random() * 100);
queue.offer(x);
emptyCondition.signalAll();
System.out.printf("producer: %d and signal all. queue = %d /n",
x, queue.size());
}
finally
{
locker.unlock();
}
}

Consumer线程被中断后不结束，直到队列内所有数据被输出。
不使用Thread.currentThread().isInterrupted()而定义isInt记录中断，可以避免中断导致ReentrantLock方法的tryLock不能获得锁而直接抛出异常。

public void run()
{
// 线程是否被中断
boolean isInt = false;
// 线程中断后，将队列内的数据全部读出，再结束线程。
while (!isInt || !queue.isEmpty())
{
try
{
consume();
Thread.sleep((int)(Math.random() * 3000));
}
catch (InterruptedException e)
{
isInt = true;
}
}
System.out.println("consumer: end.");
}
private void consume() throws InterruptedException
{
if (!locker.tryLock(5, TimeUnit.SECONDS))
{
// 没有获得锁,不进行任何操作。避免死锁。
return;
}
try
{
// Consume
while (queue.isEmpty())
{
System.out.println("consumer: waiting for condition.");
if (!emptyCondition.await(5, TimeUnit.SECONDS))
{
// 5秒没有等待到条件，不进行任何操作。
// 避免中断后在此处等待。
return;
}
}
int x = queue.poll();
System.out.printf("consumer: %d, queue=%d /n", x, queue.size());
}
finally
{
locker.unlock();
}
}

PART.7 处理BlockingQueue

使用BlockingQueue处理Consumer和Producer问题。
put和take方法可以在线程被中断时抛出InterruptedException。

Producer:

public void run()
{
try
{
while (true)
{
int x = (int)(Math.random() * 100);
queue.put(x);
System.out.println("producer: " + x);
Thread.sleep((int)(Math.random() * 3000));
}
}
catch (InterruptedException e)
{
}
System.out.println("producer: end.");
}

Consumer:

public void run()
{
try
{
while (true)
{
int x = queue.take();
System.out.println("consumer: " + x);
Thread.sleep((int)(Math.random() * 3000));
}
}
catch (InterruptedException e)
{
}
System.out.println("consumer: end.");
}

PART.8 处理Socket和ServerSocket

1. 处理ServerSocket的accept方法

调用ServerSocket的setSoTimeout方法设置超时时间。
捕获并处理超时引起的SocketTimeoutException。
不需要处理该异常。

public void run()
{
try
{
// 设置超时时间
serverSocket.setSoTimeout(2000);
}
catch (SocketException e)
{
e.printStackTrace();
System.exit(-1);
}
while (!Thread.currentThread().isInterrupted())
{
try
{
@SuppressWarnings("unused")
Socket s = serverSocket.accept();
}
catch (SocketTimeoutException e)
{
// 超时，不进行任何处理，再次调用accept方法
}
catch (IOException e)
{
e.printStackTrace();
}
}
// 清理工作
}

2. 处理包装自Socket的BufferedReader的readLine方法

调用Socket的setSoTimeout方法设置超时时间。
BufferedReader的readLine方法在阻塞指定的时间后将抛出SocketTimeoutException。
不需要处理该异常。

public void run()
{
BufferedReader reader = null;
try
{
// 建立测试用的链接
serverSocket = new ServerSocket(10009);
socket = new Socket("127.0.0.1", 10009);
Thread.sleep(500);
Socket s = serverSocket.accept();
// 向socket发送5行数据
OutputStreamWriter w = new OutputStreamWriter(
s.getOutputStream());
w.write("line1 /n line2 /n line3 /n line4 /n line5 /n");
w.flush();
// 设置超时
socket.setSoTimeout(1000);
// 创建BufferedReader
reader = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
}
catch (IOException e)
{
e.printStackTrace();
System.exit(-1);
}
catch (InterruptedException e)
{
e.printStackTrace();
System.exit(-1);
}
while (!Thread.currentThread().isInterrupted())
{
try
{
String s = reader.readLine();
if (s == null)
{
// 流结束
break;
}
// 输出读取的数据
System.out.println("thread: " + s);
}
catch (SocketTimeoutException e)
{
System.out.println("thread: socket timeout.");
}
catch (IOException e)
{
e.printStackTrace();
}
}
// 清理
try { serverSocket.close(); } catch (Exception e) { }
try { socket.close(); } catch (Exception e) { }
System.out.println("thread: end.");
}

3. 处理包装自Socket的ObjectInputStream的readObject方法

与readLine的处理方法类似。
调用Socket的setSoTimeout方法设置超时时间。
ObjectInputStream的readObject方法在阻塞指定的时间后将抛出异常。
不需要处理该异常。

public void run()
{
ObjectInputStream ois = null;
try
{
// 建立测试用的链接
serverSocket = new ServerSocket(10009);
socket = new Socket("127.0.0.1", 10009);
Thread.sleep(500);
Socket s = serverSocket.accept();
// 向socket发送3个对象
ObjectOutputStream oos = new ObjectOutputStream(
s.getOutputStream());
oos.writeObject(new TestData("object 1"));
oos.writeObject(new TestData("object 2"));
oos.writeObject(new TestData("object 3"));
// 设置超时
socket.setSoTimeout(1000);
// 创建ObjectInputStream
ois = new ObjectInputStream(socket.getInputStream());
}
catch (IOException e)
{
e.printStackTrace();
System.exit(-1);
}
catch (InterruptedException e)
{
e.printStackTrace();
System.exit(-1);
}
while (!Thread.currentThread().isInterrupted())
{
try
{
TestData s = (TestData)ois.readObject();
if (s == null)
{
// 流结束
break;
}
// 输出读取的数据
System.out.println("thread: " + s.data);
}
catch (SocketTimeoutException e)
{
System.out.println("thread: socket timeout.");
}
catch (IOException e)
{
e.printStackTrace();
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
}
// 清理
try { serverSocket.close(); } catch (Exception e) { }
try { socket.close(); } catch (Exception e) { }
System.out.println("thread: end.");
}

其中，TestData是一个简单的可序列化的类。

private static class TestData implements Serializable
{
private static final long serialVersionUID = 6147773210845607198L;
public String data;
public TestData(String data)
{
this.data = data;
}
}

PART.9 总结

见“PART.2可中断的线程”和“PART.4 处理阻塞”。