多线程学习（基础篇一）

什么是线程？什么是进程？

学习多线程，首先要明白什么是线程，在谈线程之前，不得不提的是进程，因为线程是进程中的一个实体，线程本身不会独立存在。
操作系统在分配系统资源的时候，是把资源分配给进程的，进程是系统进行资源分配和调度的基本单位。
由于CPU的资源比较特殊，它是被分配到线程的，所以线程是CPU分配资源的基本单位。
进程中至少有一个线程，进程中的多个线程共享进程的资源。

进程与线程各自占有哪些资源？

进程

进程占有堆内存和方法区。
堆内存： 堆是进程中最大的一块内存，里面主要存放通过new创建的对象实例。堆内存分为两大块，即新生代和老年代，其中新生代=一个Eden区+两个Survivor区，每次只使用Eden和Survivor中的一块，优化虚拟机的时候主要就是对堆内存进行优化。
方法区： 虚拟机加载类的时候，读取的类的相关信息都会存到方法区，如类全限定名、常量、静态变量、访问修饰符等。

线程

线程占有程序计数器和栈。
程序计数器： 用来记录线程当前要执行的指令地址。因为cpu一般是使用时间片轮转方式让线程占用，当前线程cpu时间片用完后，要让出cpu，等下次轮到自己时再执行，所以要用程序计数器记录该线程让出cpu时的执行地址，待再次分配到时间片时，就可以从计数器指定的地址继续执行。
栈： 用于存储线程的局部变量，这些局部变量是该线程私有的，其它线程访问不了。

多线程的实现方式

方式一

继承Thread类，重写run方法，代码如下：

new Thread() {
			@Override
			public void run() {
						System.out.println(currentThread().getName());
			}
}.start();

底层代码

@Override
 public void run() {
		if (target != null) {
		      target.run();
		}
 }

很简单，需要对target判断，如果不为空则执行run方法，可是我们不知道target是什么，如果想要使用线程，所以需要对源代码做更改，而我们通常不直接更改源码，采用的手段是重写，即重写父类的run方法，至于target是什么，等会再说。

方式二

实现Runnable接口，创建线程，那么怎么实现呢？
刚才看过Thread类中的run方法，那么target到底是什么呢？我们来找一下，

/* What will be run. */
  private Runnable target;

原来target是个Runnable对象，继续查找我们会发现，target会在一个私有的init方法中被赋值，

private void init(ThreadGroup g, Runnable target, String name,
                      long stackSize, AccessControlContext acc,
                      boolean inheritThreadLocals) {
        if (name == null) {
            throw new NullPointerException("name cannot be null");
        }
        ....
        this.target = target;
        ....
 }

但是init方法是私有的，我们没法调用，继续找找看看调用init的方法，

public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
}

找到了Thread的另一个构造方法，也就是说创建Thread对象时，我们传入一个Runnable对象，即：

new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
			}		
}).start();

这样就可以啦。
另外，思考一个问题，如果同时子类复写了run方法，又传入了Runnable对象，那么会执行哪个run方法呢？代码如下：

public class ThreadCreate {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("Runnable："+Thread.currentThread().getName());
			}
		}) {
			@Override
			public void run() {
				System.out.println("Thread:"+Thread.currentThread().getName());
			}
		}.start();
	}
}

首先我们来屡下这段代码的结构再来分析，差不多简化一下是这样的：

new Thread(runnable.run()){thread.run()}.start();

直接看结果吧：

Thread:Thread-0

说明执行的是子类的run方法，原因很简单，因为子类覆盖了父类的run方法，所以理所当然的执行子类的run方法；反之，如果没有覆盖，则执行父类的run方法。

方式三

使用FutureTask方式，实现Callable接口，重写call方法，代码如下：

public class CallableThreadTest implements Callable<String>{
		public static void main(String[] args) {
			FutureTask<String>ft=new FutureTask<>(new CallableThreadTest());
			new Thread(ft).start();
			String s="";
			try {
				 s=ft.get();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (ExecutionException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(s);
		}
		@Override
	public String call() throws Exception {
				// TODO Auto-generated method stub
				return "hello";
	}
}

通过Futuretask可以拿到任务的返回结果，最后打印hello。

方式四

通过线程池创建线程，代码如下：

public class ThreadPoolTest {
	public static void main(String[] args) {
		ExecutorService  pool=   Executors.newFixedThreadPool(5);
		//ExecutorService  pool=   Executors.newCachedThreadPool();
		//ExecutorService  pool=   Executors.newSingleThreadExecutor();
		for(int j=1;j<=10;j++) {
			final int task=j;
			pool.execute(new Runnable() {//也可以使用pool.submit(new Runnable(){})方式
f				@Override
				public void run() {
					for(int i=1;i<=10;i++) {
						System.out.println("当前执行任务："+Thread.currentThread().getName()+",外循环第"+task+"次，内循环第："+i+"次");
					}
				}
				
			});
			
		}
		pool.shutdown();
	}

}

线程的生命周期

1、初始化状态

通过new创建一个线程对象，这时还没有调用它的start方法，此时线程没有被分配任何资源，这时称为初始化状态。

2、可运行状态

当调用了start方法之后，它会自动调用线程的run方法，此时线程如果得到了cpu时间就可以运行，否则继续等待，但无论是否获得了cpu时间，此时线程都处于可运行状态。

3、阻塞状态

通过某些方法，比如sleep、wait可以把线程从可执行状态挂起，此时线程不会分配到cpu时间，因此无法执行，这时称之为阻塞状态。

4、死亡状态

当线程run方法中正常运行结束后就进入了死亡状态，或者通过stop、destory方法也会非正常地终止线程，使其进入死亡状态，之后线程就不存在了。

线程通知与等待

wait()

当一个线程调用wati()方法时（调用wait的线程必须事先获取监视器锁，比如在同步代码块或同步方法中，否则会抛异常），该调用线程会被阻塞挂起，直到遇到下面几种情况才会返回：
1、其它线程调用了notify、notifyAll
2、其它线程调用了该线程的interrupt，抛出异常后返回。
下面通过一个经典的生产者、消费者栗子来加深理解wait、notify配合使用，

package ThreadTongXin;
public class ProductAndConsumeTest {
	private int size=0;//生产了的数量
	public int max_size=200;//允许生产最大的数量
	//生产方法
	public synchronized void product() {
		while(size==max_size) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		size++;
		System.out.println("生产了："+size+"件产品");
		notify();
	}
	//消费方法
	public synchronized void consume() {
		while(size==0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		size--;
		System.out.println("消费了产品，还剩"+size+"件产品");
		notify();
	}
	public static void main(String[] args) {
		ProductAndConsumeTest pct=new ProductAndConsumeTest();
		Product pro=new Product(pct);
		Consume con=new Consume(pct);
		pro.start();
		con.start();
	}
}
//生产者
class Product extends Thread{
	ProductAndConsumeTest pct;
	public Product(ProductAndConsumeTest pct) {
		this.pct=pct;
	}
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			pct.product();
		}
	}
}
//消费者
class Consume extends Thread{
	ProductAndConsumeTest pct;
	public Consume(ProductAndConsumeTest pct) {
		try {
			Thread.sleep(0);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.pct=pct;
	}
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			pct.consume();
		}
	}
}

打印结果如下；

生产了：1件产品
生产了：2件产品
生产了：3件产品
生产了：4件产品
生产了：5件产品
生产了：6件产品
消费了产品，还剩5件产品
消费了产品，还剩4件产品
消费了产品，还剩3件产品
消费了产品，还剩2件产品
消费了产品，还剩1件产品
消费了产品，还剩0件产品
生产了：1件产品
生产了：2件产品
生产了：3件产品
生产了：4件产品
生产了：5件产品
生产了：6件产品
生产了：7件产品
生产了：8件产品
生产了：9件产品
生产了：10件产品
生产了：11件产品
生产了：12件产品
生产了：13件产品
生产了：14件产品
消费了产品，还剩13件产品
消费了产品，还剩12件产品
消费了产品，还剩11件产品
消费了产品，还剩10件产品
消费了产品，还剩9件产品
消费了产品，还剩8件产品
消费了产品，还剩7件产品
消费了产品，还剩6件产品
消费了产品，还剩5件产品
消费了产品，还剩4件产品
消费了产品，还剩3件产品
消费了产品，还剩2件产品
消费了产品，还剩1件产品
消费了产品，还剩0件产品

使用while进行判断，更严谨，可以防止虚假幻醒（等待超时或者被中断导致线程被唤醒，就是虚假唤醒）。
下面再通过一个栗子说明一个线程调用wati被阻塞挂起后，其它线程中断了该线程，则该线程会抛出InterruptException异常并返回。

package ThreadTongXin;

public class InterruptWaitTest {

	public static void main(String[] args) {
		Thread t=new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("t线程开始运行");
				try {
					synchronized(this) {
						
						this.wait();
					}
					System.out.println("t线程运行结束");
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		});
		t.start();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("t线程被中断之前");
		t.interrupt();
		System.out.println("t线程被中断之后");
	}

}

打印结果如下，

t线程开始运行
t线程被中断之前
t线程被中断之后
java.lang.InterruptedException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Unknown Source)
	at ThreadTongXin.InterruptWaitTest$1.run(InterruptWaitTest.java:14)
	at java.lang.Thread.run(Unknown Source)

t线程运行之后，会将自己挂起，主线程在休眠一秒后中断t线程，t线程抛出异常后返回。

notify和notifyAll

当线程调用共享对象的notify后，会唤醒一个且只能唤醒一个在该共享对象上wait挂起的线程，具体唤醒哪个等待的线程是随机的。

而notifyAll会唤醒所有在该共享变量上挂起的线程。

需要注意的是，被唤醒的线程不能马上从wait方法返回并继续执行，需要和其它线程一起竞争锁，只有得到了监视器锁之后才可以继续执行。

等待线程执行完毕的join方法

通过join可以达到指定线程按一定的顺序执行，来个栗子，

package ThreadTongXin;

public class JoinTest {

	public static void main(String[] args) {
		for(int i=1;i<=5;i++) {
			final int x=i;
			Thread t=new Thread(new Runnable() {
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println("运行的是："+x+"线程");
				}
			}) ;
			t.start();
//			try {
//				t.join();
//			} catch (InterruptedException e) {
//				// TODO Auto-generated catch block
//				e.printStackTrace();
//			}
			
		}
	}

}

创建了五个线程，如果不加join的话，执行的顺序是随机的，

运行的是：2线程
运行的是：5线程
运行的是：4线程
运行的是：3线程
运行的是：1线程

当把注释去掉之后，也就是加join方法，执行的顺序是指定的顺序，

运行的是：1线程
运行的是：2线程
运行的是：3线程
运行的是：4线程
运行的是：5线程

在main函数也就是主线程中调用t.join，会将主线程自己阻塞起来，等待t线程执行完后才继续执行主线程。

让线程睡眠的sleep方法

Thread类中有一个静态的sleep方法，当一个执行中的线程调用了Thread的sleep方法，该线程会暂时让出指定时间的执行权，也就是在睡眠期间不参与cpu的调度，但是该线程占有的锁资源不会释放。指定睡眠的时间到了之后，线程会处于就绪状态，参与cpu的调度，获取到cpu后会继续运行。如果在线程睡眠期间其它线程调用了该线程的interrupt（）方法，则该线程会在调用sleep方法的地方抛出异常并返回。

让出cpu执行权的yield

cpu是按照时间片轮询的方式被线程占有的，当一个线程的时间片结束后，线程调度器会进行线程调度，当一个线程调用Thread的静态方法yield时，表示该线程自己占有还没有使用完的时间片不想用了，也就是让出cpu使用权，然后处于就绪状态，当然也有可能刚刚让出cpu使用权，在下一轮调度时，又获得cpu使用权。

线程的中断interrupt家族

Java的线程中断并不是真的直接终止线程的执行，而是一种线程间的协作模式，通过设置线程的中断标志，然后线程自己根据中断状态自行处理。
1、void interrupt（）： 中断线程，当线程a在运行时，线程b调用线程a的interrupt（）方法来设置线程a的中断标志为true并立即返回，线程a实际上并没有被中断，它会继续往下执行；
如果线程a因调用wait、join、sleep被阻塞挂起，这时候b线程调用a线程的interrupt方法，a线程会在调用这些方法的地方抛出异常并立即返回，
举个栗子把，

public static void main(String[] args) throws InterruptedException {
		Thread t=new Thread(new Runnable() {
			@Override
			public void run() {
//		               try {
//							Thread.sleep(1000);
//						} catch (InterruptedException e) {
//							// TODO Auto-generated catch block
//							e.printStackTrace();
//						}
				for(int i=0;i<6;i++) {
					System.out.println(i+" "+Thread.currentThread().isInterrupted());
				}
			}
		});
		t.start();
		t.interrupt();

打印结果为

0 true
1 true
2 true
3 true
4 true
5 true

上述代码，创建了一个线程t，打印6个数，在开启线程之后，main中调用t.interrupt()中断t线程，通过isInterrupted（isInterrupted，检测当前线程是否被中断，是返回true，否则返回false）方法可以看到，t线程已经被中断，但是并没有终止执行。

如果将注释的代码放开的话，打印结果如下，

java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at ThreadTongXin.interruptThread$1.run(interruptThread.java:10)
	at java.lang.Thread.run(Unknown Source)
0 false
1 false
2 false
3 false
4 false
5 false

当线程t处于sleep时，主线程调用了它的interrupt方法，这时会强制在sleep处抛出异常而立刻返回，线程会恢复到激活状态，所以isInterrupted打印为false。（另外，如果你将sleep时间调整尽可能的长，比如10秒或20秒，调用t.interrupt()方法，会立即抛出异常，并返回）

2、boolean isInterrupted（）： 检测当前线程是否被中断，如果是返回true，否则返回false。

3、boolean interrupted（）： 检测当前方法是否被中断，如果是返回true，否则返回false。与isInterrupted不同的是，该方法如果发现当前线程被中断，则会清除中断标志，并且该方法是个static方法，可以直接用Thread调用，还有一点，在interrupted（）内部是获取当前调用线程的中断标志，而不是被调用线程的中断标志，话不多说，直接来个栗子品味一下interrupted和isInterrupted的区别，

public static void main(String[] args) throws InterruptedException {
		Thread t=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("调用interrupted之前 "+Thread.currentThread().interrupted());
				System.out.println("调用interrupted之后"+Thread.currentThread().interrupted());
			}
		});
		t.start();
		t.interrupt();
	}

打印结果为，

调用interrupted之前 true
调用interrupted之后false

第一行打印说明，t线程确实被中断了，返回true，但同时清除了中断标志，所以第二行打印false。

在通过一个栗子，

public static void main(String[] args) throws InterruptedException {
		Thread t=new Thread(new Runnable() {
			@Override
			public void run() {
				for(;;) {
				}
			}
		});
		t.start();
		t.interrupt();
		System.out.println("t.isinterrupted "+t.isInterrupted());
		System.out.println("t.interrupted "+t.interrupted());
		System.out.println("t.isinterrupted "+t.isInterrupted());
		System.out.println("thread.isinterrupted "+Thread.interrupted());
	}

t.isinterrupted true
t.interrupted false
t.isinterrupted true
thread.isinterrupted false

第一行很好理解，第二行为什么是false呢？t不是中断了吗？如果你有这样的疑问，说明还是没有理解interrupted方法的含义，它返回的是当前线程的中断状态，而不是调用interrupted方法的对象线程的中断标志，当前线程为main线程，虽然写的是t.interrupted,但是它实际上返回的是main线程的状态，与第四行的Thread.interrupted方法是同一个意思，main线程没有中断，所以为false。

守护线程和用户线程