02 Java 并发 JDK1.5之前的多线程

Java 1.5之前的版本，只提供了有限的多线程支持。1.5之前提供的多线程功能实在太过简陋，实际工作中已经很少用到了。本章简单介绍下 JDK 1.5 之前的多线程。

---

定义并启动一个线程

应用程序在创建一个线程实例时，必须提供需要在线程中运行的代码。有两种方式去做到这一点：

1 提供一个 Runnable对象。Runnable对象仅包含一个run()方法，在这个方法中定义的代码将在会线程中执行。将Runnable对象传递给Thread类的构造函数即可。

2 继承  Thread 类。Thread类自身已实现了Runnable接口，但它的run()方法中并没有定义任何代码。应用程序可以继承与Thread类，并复写run()方法。

public class SimpleThread implements Runnable {
    private int number;
    public SimpleThread(int number) {
        this.number = number;
    }
    @Override
    public void run() {
        for (int i=1;i<=10;i++){
            System.out.printf("%s %d * %d = %d \n", Thread.currentThread().getName(), number, i, i * number);
        }
    }
    public static void main(String[] args) {
        for(int i=1;i<10;i++){
            SimpleThread cal = new SimpleThread(i);
            Thread t = new Thread(cal);
            t.start();
        }
    }
}

中断线程

Java 提供一种中断机制用于控制线程结束。这种机制的特点是：Thread 必须主动检查是否有中断发生，自己决定是否停止当前线程。

通过调用 Thread 的interrupt()方法，发送中断信号。被中断的线程必须自己处理中断.

中断机制通过使用称为 中断状态的内部标记来实现。当线程通过调用静态方法  Thread.interrupted() 检测中断时，中断状态会被清除。非静态的  isInterrupted() 方法被线程用来检测中断状态，不改变中断状态标记。

public class InterruptedThread extends Thread {
    @Override
    public void run() {
        long number = 1L;
        while(true){
            // 非阻塞方法，需要检测是否被外部中断
            if (isInterrupted()) {
                System.out.printf("Thread is Interrupted \n");
                return;
            }
            if(isPrime(number)){
                System.out.printf("Number %d is Prime \n",number);
            }
            number++;
        }
    }

    private boolean isPrime(long number) {
        if (number <= 2) {
            return true;
        }
        for (long i = 2; i < number; i++) {
            if ((number % i) == 0) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Thread thread = new InterruptedThread();
        thread.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //中断线程
        System.out.printf("thread.interrupt() \n");
        thread.interrupt();
    }
}

public class InterruptedUsage {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "....");

        BlockingQueue<BigInteger> primes = new ArrayBlockingQueue<BigInteger>(100);
        PrimeGenerator primeGenerator = new PrimeGenerator(primes);
        primeGenerator.start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        primeGenerator.cancel();
        System.out.println(primeGenerator.isInterrupted());
        System.out.println(primes);
    }
}

class PrimeGenerator extends Thread {
    private final BlockingQueue<BigInteger> queue;

    PrimeGenerator(BlockingQueue<BigInteger> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            BigInteger p = BigInteger.ONE;
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName() +"...."+    queue.size());
               p= p.nextProbablePrime();
                queue.put(p);
            }
        } catch (InterruptedException e) {
           Thread.currentThread().interrupt();
        }
    }

    public void cancel(){
        interrupt();
    }
}

也可以通过抛出 InterruptedException ，控制中断

        // 检测是否被外部中断,中断状态会被清除
        if ( Thread.interrupted()) {
             throw new InterruptedException();
        }

---

Thread类定义了一些对线程管理十分有用的的方法。在这些方法中，有一些静态方法可以给当前线程调用，它们可以提供一些有关线程的信息，或者影响线程的状态。而其他一些方法可以由其他线程进行调用，用于管理线程和Thread对象。

---

暂停线程

使用 Thread.sleep()方法可以暂停当前线程一段时间。也可以用  TimeUnit.SECONDS.sleep(1);

在Thread中有两个不同的sleep()方法，一个使用毫秒表示休眠的时间，而另一个是用纳秒。由于操作系统的限制休眠时间并不能保证十分精确。休眠周期可以被interrupts所终止，我们将在后面看到这样的例子。不管在任何情况下，我们都不应该假定调用了sleep()方法就可以将一个线程暂停一个十分精确的时间周期。

---

等待线程结束

Join()方法可以让一个线程等待另一个线程执行完成。若t是一个正在执行的Thread对象， t.join() 将会使当前线程暂停执行并等待t执行完成。重载的join()方法可以让开发者自定义等待周期。然而，和sleep()方法一样join()方法依赖于操作系统的时间处理机制，你不能假定join()方法将会精确的等待你所定义的时长。

如同sleep()方法，join()方法响应中断并在中断时抛出InterruptedException。

public class JoinThread {
    public static void main(String[] args) {
        DataSourcesLoader dsLoader = new DataSourcesLoader();
        Thread thread1 = new Thread(dsLoader,"data sources");

        NetworkConnectionsLoader ncLoader = new NetworkConnectionsLoader();
        Thread thread2 = new Thread(ncLoader, "NetworkConnectionLoader");
        thread1. start();
        thread2. start();
        try {
            // 等待线程结束
             thread1.join();
             thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("Main: Configuration has been loaded:  %s\n",new Date());
    }
}

---

线程中的异常处理

对于非检查异常，可以通过ExceptionHandler 统一捕捉

public class ExceptionHandler implements Runnable,Thread.UncaughtExceptionHandler{
    public static void main(String[] args) {
        ExceptionHandler task=new ExceptionHandler();
        Thread thread=new Thread(task);
        thread.setUncaughtExceptionHandler(task);
        thread.start();
    }
    @Override
    public void run() {
        // 模拟错误
        int numero=Integer.parseInt("TTT");
    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.printf("An exception has been captured\n");
        System.out.printf("Thread: %s\n",t.getId());
        System.out.printf("Exception: %s: %s\n",e.getClass().
                getName(),e.getMessage());
        System.out.printf("Stack Trace: \n");
        e.printStackTrace(System.out);
        System.out.printf("Thread status: %s\n",t.getState());
    }
}