Java多线程基础(二)

Z时代
2024-01-10
分类：综合

java

　　信号量Semaphore，类似于锁的功能，用于多线程中对一组资源的控制。

　　acquire方法用于尝试获取一个资源，未获取前将一直等待。release用于释放一个资源，release的前提是已经获得了一个资源。　

package multiThread;
import java.util.concurrent.Semaphore;
public class SemaphoreTest {
    public static void main(String [ ] args) {
        int N = 8; //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for (int i = 1; i < N; i++)
            new Worker(i, semaphore).start();
    }
    static class Worker extends Thread {
        private int num;
        private Semaphore semaphore;
        public Worker(int num, Semaphore semaphore) {
            this.num = num;
            this.semaphore = semaphore;
        }
        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人" + this.num + "占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人" + this.num + "释放出机器");
                semaphore.release();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

　　运行的结果为：

工人1占用一个机器在生产...

工人3占用一个机器在生产...

工人2占用一个机器在生产...

工人4占用一个机器在生产...

工人5占用一个机器在生产...

工人3释放出机器

工人2释放出机器

工人6占用一个机器在生产...

工人4释放出机器

工人1释放出机器

工人5释放出机器

工人7占用一个机器在生产...

工人6释放出机器

工人7释放出机器

　　如果在获取资源的过程中不希望一直等待，也可以使用下面的方法判断是否能获取资源。

　　tryAcquire(),尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false。

　　tryAcquire(long timeout, TimeUnit unit），尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false。

　　Thread的run方法是不抛出任何检查型异常(checked exception)的,但是它自身却可能因为一个异常而被终止，导致这个线程的终结。最麻烦的是，在线程中抛出的异常即使使用try...catch也无法截获，因此可能导致一些问题出现，比如异常的时候无法回收一些系统资源，或者没有关闭当前的连接等等。
　　如果程序里面使用了多线程技术的话!就需要对子线程的异常做出特殊的处理,如果没有做特殊处理的话,好像子线程的异常不会抛给主线程,有时会直接在客户端抛出异常(这当然不是我们想要的),更夸张的是,有时直接把程序给强制关闭了!
　　如下面的例子，即使main线程中加上了try-catch也无法捕获子线程抛出的异常：

package multiThread.exception;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExceptionThread implements Runnable{    
    @Override
    public void run() {
        throw new RuntimeException();
    }
    public static void main(String [ ] args) {
        try {
            ExecutorService exec = Executors.newCachedThreadPool();
            exec.execute(new ExceptionThread());
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}

　　输出为：

Exception in thread "pool-1-thread-1" java.lang.RuntimeException

at multiThread.exception.ExceptionThread.run(ExceptionThread.java:10)

at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)

at java.lang.Thread.run(Unknown Source)

　　可以创建线程时绑定UncaughtExceptionHandler，UncaughtExceptionHandler的uncaughtException方法会在线程死亡前被调用。

package multiThread.exception;
import java.lang.Thread.UncaughtExceptionHandler;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
class ExceptionThread2 implements Runnable{        
    @Override
    public void run() {
        System.out.println("eh = " + Thread.currentThread().getUncaughtExceptionHandler());
        throw new RuntimeException();
    }
}
class MyUncaughtExceptionHandler implements UncaughtExceptionHandler{
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println(t.getName() + " caught " + e);
    }    
}
class HandlerFactory implements ThreadFactory{
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
        return t;
    }
}
public class CaptureUncaughtException {
    public static void main(String [ ] args) {
        ExecutorService exec = Executors.newCachedThreadPool(new HandlerFactory());
        exec.execute(new ExceptionThread2());
    }    
}