原来不认识的单线程和多线程

Redis是单线程的，Servlet是单实例多线程的，突然发现曾经认识的线程已经不再是我认识的单纯的线程了，它变了，变得我开始需要慢慢的熟悉它了，希望我们以后会是好朋友。

单线程和多线程都得学，所以这次先看看线程的生命周期：

一、线程的生命周期

 当初简单继承Thread类，然后重写run() 方法，创建并且启动线程即可，又或者实现Runnable接口这个类并重写它的run () 方法，然后再创建一个实现类和线程类，调用其start() 方法就可以创建一个线程来使用了。

    // 实现Runnable
    public static void main(String[] args) {
        Runner runner = new Runner();
        Thread thread = new Thread(runner);
        thread.start();
    }
    static class Runner implements Runnable{
        @Override
        public void run() {
            for (int i = 0; i <10; i++) {
                System.out.println("操作实现"+i);
            }
        }
    }


    //或者继承Thread类
    public class ThreadTest extends Thread {
    @Override
    public void run() {
        for (int i = 0; i <10; i++) {
            System.out.println("操作内容"+i);
        }
    }
    public static  void main(String[] args) {

        ThreadTest cTest = new ThreadTest();
        c.run();
    }

现在发现 原来还有一种方法，使用匿名内部类创建线程和使用jdk8的一种神奇方式创建

     //匿名内部类创建线程
     new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello1  thread");
            }
        }).start();

        //jdk1.8 实现
        new Thread( () -> {System.out.println("hello1");} ).start();

       实现new 一个 Thread就可以使用其Strat() 方法来让一个线程进入Runnable就绪状态，然后等待JVM虚拟机任务调度调用该方法使其运行起来。执行run()方法的线程执行体，则该线程处于Running运行状态,当run()运行结束、使用stop()或者抛异常的时候就会进入dead死亡状态。

    public static  void main(String[] args) throws InterruptedException {
            Thread a = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("start A~");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("~end A");
                }
            });
            Thread b = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("start B~");
                    try {
                        sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("~end B");
                }
            });
            a.start();
            b.start();
            //在执行的时候先让线程A，线程B执行完再执行主线程
            //a、b运行不受影响，a.join() 等待a线程执行完毕再接着执行a.join()所在的线程
            a.join();
            b.join();
            System.out.println("end");
        }



   //sleep() 方法的使用 睡眠多少毫秒，不释放所在线程锁
    public static void main(String[] args) {
        System.out.println(df.format(new Date()));
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(df.format(new Date()));
    }

然而 join() 和 sleep()的话，使得线程进入了阻塞(Blocked)状态，只有当 sleep() 结束或者interrupt()中断和  join()中断的时候，线程会回到Runnable就绪状态，等待JVM的调度。

    /**
     * wait()调用后，释放调用wait对象的线程锁，如果对象不占用锁则报IllegalMonitorStateException
     * 无参 则会一直等直到 notify()或notifyAll()
     * wait(1000) 单位毫秒 超时自动被唤醒
     */
        public static  void main(String[] args) throws InterruptedException {
            CompareTest test = new CompareTest();

            //过一会细细讲讲使用synchronized来保证线程安全
            // new CompareTest().wait(); 直接调用会报IllegalMonitorStateException
            //没有锁所以也会报IllegalMonitorStateException
        synchronized (test) {
            System.out.println("当前线程"+Thread.currentThread().getName());
            test.wait(1000);
        }
    }

wait()  方法直接使得线程进入了阻塞(Blocked)状态，这个时候Wait() 方法是释放锁的。这个时候会使该线程处于等待池(wait blocked pool),直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable），等待JVM调度。接下来看看notify() 和notifyAll()方法的使用。

public class ThreadTest extends Thread {
    static Boolean FLAG = true;
    @Override
    public void run() {
        try {
            synchronized (ThreadTest.class) {
                if (FLAG){
                    System.out.println("wait 等待开始
                     无参数则会一直等直到 notify()或notifyAll()");
                    ThreadTest.class.wait();
                    System.out.println("wait 结束 
                    对在多线程间共享的那个Object来使用wait,
                    在生产者消费者问题中，这个共享的Object就是那个缓冲区队列。");

                }else {
                    System.out.println("notify start");
                    ThreadTest.class.notify();
                    System.out.println("notify end");
                }

            }

        } catch (InterruptedException e) {
        e.printStackTrace();
    }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadTest test1 = new ThreadTest();
        ThreadTesttest2 = new ThreadTest();
        test1.start();
        sleep(1000);
        FLAG = false;
        test2.start();
        System.out.println("主线程在跑~");


    }
}

 notify()是唤醒一个正在等待该对象的线程而notifyAll()是唤醒所有正在等待该对象的线程。notifyAll使所有原来在该对象上等待被notify的线程统统退出wait的状态，变成等待该对象上的锁，一旦该对象被解锁，他们就会去竞争。
notify只是选择一个wait状态线程进行通知，并使它获得该对象上的锁，但不惊动其他同样在等待被该对象notify的线程们，当第一个线程运行完毕以后释放对象上的锁，此时如果该对象没有再次使用notify语句，即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，继续处在wait状态，直到这个对象发出一个notify或notifyAll，它们等待的是被notify或notifyAll，而不是锁。

wait()方法和notify()/notifyAll()方法要在同步块中被调，wait()方法和notify()/notifyAll()方法在调用前都必须先获得对象的锁。

public class NewThread extends Thread{

    private static  Boolean BOOLEAN = true;
    @Override
    public void run() {
        synchronized (NewThread.class) {
            if (BOOLEAN) {
                try {
                    System.out.println("wait start");
                    NewThread.class.wait();
                    System.out.println("wait end");
                } catch (InterruptedException e) {

                }
            } else {
                System.out.println("notify start");
                NewThread.class.notify();
                System.out.println("notify end");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        NewThread newThread = new NewThread();
        NewThread v2_3 = new NewThread();
        newThread.start();
        sleep(10);
        BOOLEAN = false;
        v2_3.start();
    }

我们从线程的状态转化可以看到 interrupt() 和notify()/notifyAll()是一样的作用，其实interrupt()常常被用来终止“阻塞状态”线程。但是interrupt() 其实是中断本线程，因为线程是可以被自己中断的。

当线程调用了wait(), wait(long)或wait(long, int)会让它进入等待(阻塞)状态， 还有使其进入阻塞状态的有调用线程的join(), join(long), join(long, int), sleep(long), sleep(long, int) 当线程进入阻塞状态，可能是被阻塞在一个Selector选择器中，interrupt()中断本线程， 本线程的中断标记会被设为true，并且它会立即从选择操作中返回。 如果不是被阻塞在Selector选择器，interrupt()中断线程时，它的中断标记会被设置为“true”。 中断一个“已终止的线程”不会产生任何操作。

  有关yield()方法，这个方法可以将Running的线程变成Runnable的就绪状态，线程在 this.start()准备执行 到 就绪状态 ，run()运行就是运行状态。

  大致先写到这里，后续会继续和线程打交道的。