线程并发二：线程基本操作

1. 创建线程
   常用创建线程有两种方法， 第一种发放使用匿名内部类，重载run() 方法，第二种使用Runnable接口创建线程：

//方法一Thread t1 = new Thread(){    @Override    public void run(){        System.out.prinln("hello!!");    }}//方法二public class testThread implements Runnable {    public static void main(String[] args){        Thread t1 = new Thread(new testThread());        t1.start;    }    @Override    public void run(){        System.out.println("world");    }}

2.终止线程
Thread 提供了一个stop()方法，但是stop()方法是一个被标注为废弃的方法，Thread.stop()方法在结束线程时，会直接终止线程，并且会立即释放这个线程所持有的锁，强行把执行到一半的线程终止，可能会引起一些数据不一致的问题。

3.线程中断
线程中断是一种重要的线程协作机制，从字面上理解，中断是让目标线程停止执行，实际上并非如此，线程中断并不会使线程立即退出，而是给线程发送一个通知，告知目标线程，需要终止，至于是否终止，由目标线程自行决定。和线程中断有关的方法有三个：

public void Thread.interrupt()        //中断线程public boolean Thread.isInterrupted()           //判断是否被中断public static boolean Thread.interrupted()        //判断是否被中断，并清除当前中断状态

4.利用中断实现终止线程

public static void main(String[] args) throws InterruptedException {    Thread t1 = new Thread(){        @Override        public void run(){            while(true){                if(Thread.currentTread().isInterrupted()){                    System.out.println("Interruted!");                    break;                }                try{                    Thread.sleep(2000);                } catch (InterruptedException e){                    System.out.println("Interruted when sleep!");                    Thread.currentThread().interrupt();                }            }        }    };    t1.start();    Thread.sleep(1000);    tl.interrupt();}

5.等待（wait） 和 通知（notify）
wait() 和 notify() 的输出并不是Tread类，而是Object类， 当一个线程调用了object.wait(), 那么它就进入了object对象的等待队列。这个等待队列中，可能会有多个线程，因为系统运行中可能多个线程同时等待某一个对象。当object.notify()被调用时，它就会从这个等待队列中，随机选择一个线程，并将其唤醒。但是这个选择是不公平的，并不是先等待线程会优先被选择，这个选择完全是随机的。
除了notify()接口之外，Object对象还有一个notifyAll()方法，该方法会唤醒在这个等待队列中所有等待的线程。
无论是wait()和notify()都必须包含在对应的syncchronzied语句中，都需要首先获得目标对象的一个监视器。

public class SimpleTest(){    final static Object object = new Object();    public static class T1 extends Thread {        public void run(){            synchronized(object){                try{                    object.wait();                } catch (InterruptedException e){}            }        }    }    public static class T2 extends Thread {        public void run(){            synchronized (object) {                object.notify();            }        }    }    public static void main(String[] args){        Thread t1 = new T1();        Thread t2 = new T2();        t1.start();        t2.start();    }}

6.挂起（suspend） 和继续执行（resume）线程
Thread类的API提供了两个看起来非常有用的即可：挂起（suspend）、继续执行（resume）。但是这俩个方法不推荐使用，因为suspend()在导致线程挂起的时候，并不会释放任何资源锁，此时其他任何线程想要访问被它暂用的锁时，都会导致无法继续运行，直到对应的线程上进行了resume()操作。如果resume() 操作意外的在suspend()前执行，那么被挂起的线程可能很难有机会被继续执行。而且，对于被挂起的线程，从它线程状态上来看，还是Runnable,这严重影响我们对系统当前状态的判断。
那如果需要比较靠谱的suspend()函数该怎么办呢，我们可以用notify()和wait()方法在应用层面实现suspend()和resume()， 如下：

public class GoodSuspend {    public static Object u = new Object();    public static class ChangeObjectThread extends Thread {        volatile boolean suspendme = false;        public void suspendMe(){            synchronized (u){                System.out.println("wwwwwwwwwwwwwwwwwwwwwww!");                suspendme = true;            }        }        public void resumeMe(){            suspendme = false;            synchronized (u){                u.notify();            }        }        public void run(){            while(true){                synchronized (u){                    if (suspendme) {                        try {                            u.wait();                        } catch (Exception e) {                            e.printStackTrace();                        }                    }                }                synchronized (u) {                    try {                        Thread.sleep(200);                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                    System.out.println("in changeObjectThread!");                }                Thread.yield();            }        }    }    public static class ReadObjectThread extends Thread {        /*public void resumeMe(){            synchronized (u){                System.out.println("nnnnnnnnnnnnnnnnnnnnnnnnnn!");                u.notify();            }        }*/        @Override        public void run(){            while (true){                synchronized (u){                    try {                        Thread.sleep(200);                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                    System.out.println("in ReadObjectThread!");                }                Thread.yield();            }        }    }    public static void main(String[] args) throws InterruptedException {        // TODO Auto-generated method stub        ChangeObjectThread t1 = new ChangeObjectThread();        ReadObjectThread t2 = new ReadObjectThread();        t1.start();        t2.start();        Thread.sleep(1000);        t1.suspendMe();        System.out.println("suspend t1 10 sec");        Thread.sleep(10000);        System.out.println("resume t1");        t1.resumeMe();    }}

7.等待线程结束（join）和谦让（yield）
JDK提供了两个join()接口

public final void join() throws InterruptedExceptionpublic final synchronized void join(long millis) throws InterruptedException

第一个join()方法表示无线等待，他会一直阻塞当前线程，直到目标线程执行完毕。第二个方法给出一个最大等待时间，如果超过给定时间目标线程还在执行，当前线程将继续执行。
join()的本质是让调用线程wait()在当前线程对象实例上。

public class JoinTest {    public volatile static int i = 0;    public static class TestTread extends Thread {        public void run(){            for(i = 0; i < 100; i++);        }    }    public static void main(String[] args) throws InterruptedExcepion {        AddThread at = new AddThread();        at.start();        at.join();        System.out.println(i);    }}

不适用join()的情况下i是一个0或者很小的数， 但加上join()之后，打印i的值永远是100.

public static native void yield();

yield() 是一个静态方法，一旦执行，它会使当前线程退让出CPU.