多线程学习--线程基础

现代处理器的已经面向多核方向发展，为了迎合这种发展趋势，有必要学习多线程。
即多个任务同时执行。首先有必要明白两个概念：进程、线程
进程：计算机开始一个应用程序就打开一个进程。
线程：现代计算机调度的最小单元。
两者关系：一个进程可以有多个线程。for example：一个应用程序后台可能有多个线程同时工作。

线程的状态

New:线程刚刚创建完成。
Runnable:指线程已经准备就绪、或者正在运行中。
Blocked:线程因为等待锁被阻塞。
Waiting:指当前线程处于等待状态，等待别的线程做出一些动作：通知或者中断
Timed-Waiting:同样处于等待状态，只不过如果超过等待时间的话，线程会不再处于等待状态。
Terminated:线程已经执行完方法。

Daemon线程

守护线程，指常年运行的线程，会在所有线程运行结束之后自动退出。

创建线程

有两种方法：
一、通过继承Thread类，重写run方法。
二、通过runnable接口，重写run方法。
三、使用匿名类

Thread th = new Thread(){
	public void run(){
	}
};

停止线程

废弃的Stop()方法
早期时使用Stop()方法来直接停止一个线程，但是因为其线程不安全，所以现在Stop()方法已经废弃过期了
那么问什么Stop()方法是线程不安全的呢？
Stop方法会直接将线程停止，但是此时线程工作在什么地方是未知的，因此会出现很多不可预料的错误。
所以想要停止线程自己编写一个StopMe()的方法，平时将标记位记为false，在需要把线程停止的地方将标记位记为true让线程的run方法循环直接退出。

中断线程

Thread.interrupt（）可以将该线程的中断标志位设置为false； （其实该中断标志位跟之前提到的StopMe()里面的标志位很相似），可以让线程决定中断之后该如何处理。

public void main(String args[]){
	Thread th = new Thread(){
		public void run(){
			while(true){
				Thread.yield();
			}
		}
	};
	th.start();
	th.sleep(2000);
	th.interrupt();
}

这里其实把th线程置成中断状态，但是因为th并没有规定在线程中断之后应该执行什么，所以这里的中断并没有什么效果。
如果修改线程的run方法。

public void run(){
	while(true){
		if(Thread.currentThread().isinterrupted()){
			System.out.println("该线程被中断");
			break;
		}
		thread.yield();
	}
}

这里对线程设置为中断状态之后进行了一些操作，这里会反馈出来。

Thread.sleep()方法会在等待期间被中断时抛出一个InterruptException()，但是如果抛出该异常时，会把中断标志位复原。

线程之间的通信机制

这里先假设两个线程，一个用来修改一个对象的值，另一个线程用来读取该对象的值，那么这种模式可以看成一个“生产者-消费者” 的模式，那么这个时候我们希望该过程是有顺序的，即当生产者生产结束之后，消费才进行消费。

等待/通知机制

等待/通知机制可以完美地实现这种机制，首先注意一点wait()、notify()系列方法是Object类下面的方法。

如果一个线程调用了一个对象的wait（）方法，那么该线程会进入到一个队列里面等待，同时释放该对象的锁。知道有一个线程调用对象的notify（）方法，这时候对象会挑选一个队列里面的线程运行。注意这里面所有的运行条件都是在有锁的情况下进行的。

机制如下所示：

static  Object object = new Object();
    public static class  T1 implements Runnable{
        @Override
        public void run() {
            synchronized (object){
                System.out.println(System.currentTimeMillis() + "T1 start");
                try {
                    System.out.println(System.currentTimeMillis() + "T1 waiting");
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + "T1 end ");
            }
        }
    }
    public static class T2 implements Runnable{
        @Override
        public void run() {
            synchronized (object){
                System.out.println(System.currentTimeMillis() + "T2 start");
                object.notify();
                System.out.println(System.currentTimeMillis() +  "T2 end");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String args[]){
        Thread t1 = new Thread(new T1());
        Thread t2 = new Thread(new T2());
        t1.start();
        t2.start();
    }

输出结果如下所示可以看出，T1获得锁之后执行waiting方法，然后释放锁，T2获得锁，然后notify，执行结束之后释放锁，T1重新获得锁，继续执行

1570375440471T1 start
1570375440472T1 waiting
1570375440472T2 start
1570375440472T2 end
1570375442472T1 end

线程池

线程池是用于减小高并发情况下很多线程不停创建、终止以及切换上下文的消耗。
其工作原理是预先创造一个线程池，里面有事先创造了多个线程，并且不能由用户控制该线程，重复使用固定数目的线程来完成工作。
有两个好处：
1.减小了频繁创建、消亡线程的消耗。
2.使高并发情况下的工作执行变得平缓许多。