Java并发总结

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

二、线程状态

1. 线程睡眠：Thread.sleep(long millis)方法，使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。sleep()平台移植性好。

2. 线程等待：Object类中的wait()方法，导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 唤醒方法。这个两个唤醒方法也是Object类中的方法，行为等价于调用 wait(0) 一样。

3. 线程让步：Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。（上一篇文章中也介绍了yield()的用法）

4. 线程加入：join()方法，等待其他线程终止。在当前线程中调用另一个线程的join()方法，则当前线程转入阻塞状态，直到另一个进程运行结束，当前线程再由阻塞转为就绪状态。在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

5. 线程唤醒：Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。

main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实例就是在操作系统中启动了一个进程。

join()方法的使用

举个关于main()线程与子线程的区别

public class ThreadTest04 extends Thread{
    public ThreadTest04(String name){
        super(name);
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始！");
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程"+getName()+"运行："+i);
            try {
                sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程结束！");

    }
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"主线程开始！");
        ThreadTest04 name1 = new ThreadTest04("张三");
        ThreadTest04 name2 = new ThreadTest04("李四");
        name1.start();
        name2.start();
        System.out.println(Thread.currentThread().getName()+"主线程结束！");
    }
}

运行结果为：

main主线程开始！
main主线程结束！
张三线程开始！
子线程张三运行：0
李四线程开始！
子线程李四运行：0
子线程李四运行：1
子线程张三运行：1
子线程李四运行：2
子线程张三运行：2
子线程李四运行：3
子线程张三运行：3
子线程李四运行：4
子线程张三运行：4
李四线程结束！
张三线程结束！

在这里我们可以发现主线程在子线程前面结束。正如上面所说，开启子线程有时候是要在线程里计算然后返回数值给main()，这种子线程在main()线程后面结束不是我们想要的。解决方法如下：

使用线程的jion(),指等待线程终止

public class ThreadTest04 extends Thread{
    public ThreadTest04(String name){
        super(name);
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始！");
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程"+getName()+"运行："+i);
            try {
                sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程结束！");
    }
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"主线程开始！");
        ThreadTest04 name1 = new ThreadTest04("张三");
        ThreadTest04 name2 = new ThreadTest04("李四");
        name1.start();
        name2.start();
        try {
            name1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            name2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"主线程结束！");
    }
}

我们在子线程开启之后，在使用join()方法。就可以解决上面问题。

运行结果如下：

main主线程开始！
张三线程开始！
子线程张三运行：0
李四线程开始！
子线程李四运行：0
子线程张三运行：1
子线程张三运行：2
子线程张三运行：3
子线程李四运行：1
子线程李四运行：2
子线程李四运行：3
子线程李四运行：4
李四线程结束！
子线程张三运行：4
张三线程结束！
main主线程结束！

这样主线程一定在子线程结束之后结束。

sleep()方法的使用

sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程。另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield() 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 IO 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

public class ThreadTest05 implements Runnable{
    private String name;
    public ThreadTest05(String name){
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name+"线程开始");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.name+"线程结束");
    }
    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread name = new Thread(new ThreadTest05("张三"));
        name.start();
        try {
            name.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程结束");
    }
}

运行结果如下：

主线程开始
张三线程开始
张三线程结束
主线程结束

虽然这里显示了最终结果，但是在运行时可以发现，在张三线程开始显示结束之后停留了五秒钟。这就是设置的sleep()函数。这里是以毫秒为单位。

补充：

public class ThreadTest05 implements Runnable{
    private String name;
    public ThreadTest05(String name){
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println(this.name+"线程开始");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.name+"线程结束");
    }
    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread name = new Thread(new ThreadTest05("张三"));
        name.start();
        try {
            name.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程结束");
    }
}

运行结果：

主线程开始
张三线程开始///停留五秒
张三线程结束///停留五秒
主线程结束