JavaConcurrency -3-Thread操作

终止线程
Thread 提供了一个stop方法，已经废弃，强行把在执行的线程停止，可能导致数据不一致。
线程终止，我们自行决定线程何时退出：

class MyThread extends Thread{
	volatile boolean stopme = false;
	public void stopeMe(){
		stopme = true;
	}
	@Override
	public void run(){
		while(true){
			if(stopme){
				System.out.println("exit by stop me");
				break;
			}
		}
	}
}

线程中断
线程中断有关三个方法：

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

案例如下：

class MyThread extends Thread{
	@Override
	public void run(){
		while(true){
			System.out.println("Thread running");
			if(Thread.currentThread().isInterrupted()){
				System.out.println("interrput");
				break;
			}
		}
	}
}
 
public class fist{
	public static void main(String args[]) throws InterruptedException{
		Thread t1 = new MyThread();
		t1.start();
		Thread.sleep(2000);
		t1.interrupt();
	}
}

特别注意，如果在循环体中出现了wait() or sleep()这样操作的时候，中断可能被忽略。所以要再次设置中断标记位。

class MyThread extends Thread{
	@Override
	public void run(){
		while(true){
			System.out.println("Thread running");
			if(Thread.currentThread().isInterrupted()){
				System.out.println("interrput");
				break;
			}
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				System.out.println("when sleep interrupt");
				Thread.currentThread().interrupt();
			}
			System.out.println("Thread end");
		}
	}
}
 
public class fist{
	public static void main(String args[]) throws InterruptedException{
		Thread t1 = new MyThread();
		t1.start();
		Thread.sleep(1000);
		t1.interrupt();
	}
}

Thread.sleep()方法会让当前线程休眠若干时间，休眠时，如果中断线程，会抛出一个InterruptException中断异常，此时它会清除中断标志位，如果在catch住异常后，不加处理，在下次循环开始前，就无法捕获这个中断，所以要在异常助理中，再次设置中断标记位。

线程等待（wait）和通知（notify）
为了支持线程之间的协作，JDK提供了两个非常重要的接口，线程等待wait()方法和线程通知方法notify().这两个方法不是在Thread类中的，而是在Object类中的，这意味着任何对象都能调用这两种方法

public final void wait() throws InterruptException
public final native void notify()

如果一个线程调用了object.wait()方法，那么他就会进入object对象的等待队列。这个队列中可能会有多个等待线程，因为系统运行同时等待某个对象。当object.notify()被调用时，他就会从这个等待对系列中随机选择一个线程唤醒。这个唤醒是不公平的，不是先等待的线程会优先选择。
object.notifyAll()方法，他会唤醒等待队列中的所有线程。
这两个方法不是可以随便调用的，他必须包含在对应的synchronized语句中，无论是wait还是notify都需要首先获得目标对象的一个监视器。

import java.util.Objects;
public class fist{
	final static Object object = new Object();
	
	public static class MyThread_1 extends Thread{
		@Override
		public void run(){
			synchronized (object) {
				System.out.println(System.currentTimeMillis()+"T1 start");
				try {
					System.out.println(System.currentTimeMillis()+"T1 wait");
					object.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(System.currentTimeMillis()+"T1 end");
			}
		}
	}
	public static class MyThread_2 extends Thread{
		@Override
		public void run(){
			synchronized (object) {
				System.out.println(System.currentTimeMillis()+"T2 start and notify");
				object.notify();
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	public static void main(String args[]){
		Thread t1 = new MyThread_1();
		Thread t2 = new MyThread_2();
		t1.start();
		t2.start();
	}
}

开启了t1 ，t2 两个线程，t1执行了object.wait()方法。注意，在wait方法执行前，t1申请了object对象锁。因此在执行object.wait()时，持有的wait()方法执行后，t1会进行等待，并且释放object对象的锁，t2在执行notify之前也会得到object对象锁，在notify执行后释放object对象的锁。
执行效果如下：

T1 start
T1 wait
T2 start and notify
T1 end

挂起（suspend）和继续执行（resume）
两个方法都已经废弃
不推荐使用suspend()去挂起线程的原因，是因为suspend()在导致线程暂停的同时，并不会去释放任何资源锁

等待线程结束（join）和谦让（yield）

一个线程的输入可能会非常依赖另一个线程的输出，此时，这个线程就需要等待依赖线程的执行完毕，才能继续执行。

public final void join() throws InterruptedException
public final synchronized void join() throws InterruptedException

第一个join方法标识无限等待，他会一直阻塞线程，知道目标线程执行完毕，
第二个给出了一个最大等待时间，如果时间超过给定时间目标线程还在执行，当前线程会不等待，直接执行。

import java.util.Objects;
 
public class fist{
	public volatile static int  i = 0;
	public static class MyThread extends Thread{
		@Override
		public void run(){
			for(i=0;i<10000000;i++);
		}
	}
	
	public static void main(String args[]) throws InterruptedException{
		Thread t = new MyThread();
		t.start();
		t.join();
		System.out.println(i);
	}
}

如果不适用join等待myThrea线程，那么得到的可能是0或者是一个很小的数值，因为myThread线程还没有执行，i的值就被打印出来了。但在使用join方法后，标识主线程原意等待MyThread线程执行完毕，在join返回时，MyThread已经执行完毕，i为10000000

Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

其他线程相关操作
获取当前线程

Thread.currentThread()//获取当前线程
Thread.currentThread.isInterrupted()  //获取当前线程并中断线程