【JAVA并发学习三】创建线程对象

一 创建线程类

在Java中实现多线程，主要依靠java.lang.Thread类，每一个Thread对象都是一个线程，创建一个新的线程类的方法有两种：继承Thread类、实现Runable接口

1.1 继承Thread类

通过继承Thread类，并重写run( )方法，创建新的线程对象。其中run( )方法中就是线程将会执行的代码，start( )方法用于启动线程。当调用start( )方法后并不会马上开始执行多线程代码，而是让该线程进入可运行状态(Runnable)，至于具体什么时候真正运行，需要操作系统的线程调度来决定。

    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        threadTest.start();
    }

    class ThreadTest extends Thread {
        int num = 0;

        @Override
        public void run() {
          num++;
          System.out.println(num);
        }
    }

其实上面代码中的main( )方法就是一个单独的线程，每个java程序都会有两个基本线程：主线程main和GC线程

1.2 实现Runnale接口

实现Runnable接口的run( )方法，并通过Thread类的构造方法Thread( Runnable )生成线程对象，然后调用start( )方法启动线程

    public static void main(String[] args) {
        Runnable runnable = new ThreadTest();
        Thread thread = new Thread(runnable);
        thread.start();
    }

    class ThreadTest implements Runnable {
        int num = 0;

        @Override
        public void run() {
            num++;
            System.out.println(num);
        }
    }

1.3 Thread和Runnable两种方式区别

两种方式中推荐使用实现Runnable接口的方式，他的优势在于：

• 适合多个相同的程序代码的线程去处理同一个资源，创建一个Runnable对应多个Thread
• 可以解决java单继承的限制，继承Thread时无法继承其他类
• 增加程序健壮性，代码可以被多个线程共享，代码和数据独立
• 线程池只能放入Runnable和callable类线程，无法放入继承Thread的类

二 线程状态转换

• New：新创建一个线程对象
• Runnable：可运行状态，对应操作系统的就绪状态
• Running：正在运行，对应操作系统的运行状态
• Blocked：阻塞状态，当线程因为某种原因（等待IO、wait( )、获取同步锁失败）放弃CPU的使用权，暂时停止运行。直到线程再次进入就绪状态被操作系统线程调度选中才能获得CPU使用权。阻塞状态分为下面三种：
  
  • 等待阻塞：运行wait( )方法后进入等待阻塞，进入等待队列
  • 同步阻塞：运行的线程尝试获取一个对象的同步锁时，如果该对象的锁被其他线程占用，则JVM会把该线程放入锁池中，进入同步阻塞状态
  • 其他阻塞：运行的线程执行sleep( )或join( )方法、或者等待IO时，JVM会把线程设为阻塞状态。

这张图非常重要，说明了一个线程整个生命周期中状态的转换方式

三 线程调度

所谓的线程调度就是，通过不同的方法使线程完成第二节状态图中状态的变化，主要通过调用不同的API来实现

3.1 sleep( )方法

Thread.sleep( long millis )方法是Thread类的静态方法，使当前进程进入阻塞状态，millis为睡眠的时间，以毫秒为单位，时间截止后线程进入Runnable状态。

需要注意的是，执行sleep方法后，线程不会释放已经持有的锁，所以这个线程会一直持有已经获取的锁，即使该线程没有在运行

3.2 join( )方法

join( )是Thread的普通方法，他的作用是“插入新线程，并等他执行完”。例如线程t1正在运行，这时候在t1线程中生成子线程t2，执行t2.join( )方法后，JVM会把t1线程设置为阻塞状态，在t2线程执行完后，JVM才会把t1线程从阻塞状态设为Runnable状态

使用join( )方法的原因是在于，如果子线程里要进行大量耗时的运算，主线程可能往往在自线程结束之前结束。所以需要父线程等待子线程执行结束

3.3 wait( )方法

wait( long timeout)方法是Object类的普通方法。timeout为等待时间，单位为毫秒，wait方法也可以无参，此时默认默认执行wait( 0 )

有两点需要注意：

• wait方法会把当前线程持有的锁释放
• wait方法需要和notify( )、notifyAll( )方法关联执行，而且必须在synchronized(Obj) {…}代码块中执行。执行wait( )方法后线程进入等待阻塞状态，需要notify方法唤醒后才能继续获取对象锁，再次进入Runnale状态。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。

这里写一个Demo练手：建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。

    public class ThreadWaitTest implements Runnable {

        private String name;
        private Object prev;
        private Object self;

        private ThreadWaitTest(String name, Object prev, Object self) {
            this.name = name;
            this.prev = prev;
            this.self = self;
        }

        @Override
        public void run() {
            int count = 10;
            while (count > 0) {
                synchronized (prev) {
                    synchronized (self) {
                        System.out.print(name);
                        count--;

                        self.notify();
                    }
                    try {
                        prev.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }

        public static void main(String[] args) throws Exception {
            Object a = new Object();
            Object b = new Object();
            Object c = new Object();
            ThreadWaitTest pa = new ThreadWaitTest("A", c, a);
            ThreadWaitTest pb = new ThreadWaitTest("B", a, b);
            ThreadWaitTest pc = new ThreadWaitTest("C", b, c);

            new Thread(pa).start();
            Thread.sleep(1000);  //确保按顺序A、B、C执行
            new Thread(pb).start();
            Thread.sleep(1000);
            new Thread(pc).start();
            Thread.sleep(1000);
        }

3.4 notify( )方法

notify( )方法是Object类的普通方法，用于唤醒此对象监视器上等待的单个线程。如果当前对象上有多个线程在等待，则会选择唤醒其中一个线程，这种选择是任意性的

3.5 yield( )方法

yield( )方法是Thread类的静态方法，暂停当前正在执行的线程，将其设为Runnable状态，把执行机会让给相同或者更高优先级的线程。当然具体让给哪个进程执行，是由操作系统线程调度器决定，有可能线程调度器再次选择当前进程获得CPU执行权限

3.6 interrupt( )方法

interrupt( )方法是Thread类的普通方法，不要以为它是中断某个线程！它只是线线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程，但是如果你吃掉了这个异常，那么这个线程还是不会中断的！

---

参考资料

http://blog.csdn.net/evankaka/article/details/44153709#t2