结束线程，后台线程多线程讲解

线程生命周期
任何事物都是生命周期，线程也是，

1. 正常终止 当线程的run()执行完毕，线程死亡。
2. 使用标记停止线程
   注意：Stop方法已过时，就不能再使用这个方法。
   如何使用标记停止线程停止线程。
   开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，线程就结束。
   package api;

public class Thread_last {
public static void main(String[] args) {
Person1 p=new Person1();
Consumer1 con= new Consumer1§;
Producer1 pro= new Producer1§;
Thread t1=new Thread(pro,“生产者”);
Thread t2=new Thread(con,“消费者”);
t1.start();
t2.start();
//线程终止不能用stop
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
con.tag=false;
pro.tag=false;

}

}
//先些几个类
class Person1{
String name;
String sex;
boolean flag=false;
public synchronized void set(String name,String sex){
if(flag){
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

	}
	this.name=name;
	this.sex=sex;
	flag=true;
	notify();
}
public synchronized void read(){
	  if(!flag){
		  try {
			wait();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		  
		  
	  }
	  System.out.println("name: "+this.name+"   sex:  "+this.sex);
	  flag=false;
	  notify();
}

}
//生产者
class Producer1 implements Runnable{
Person1 p;
public boolean tag=true;
public Producer1() {
super();
// TODO Auto-generated constructor stub
}

public Producer1(Person1 p) {
	super();
	this.p = p;
}

public void run() {
	// TODO Auto-generated method stub
	int i=0;
	
	while(tag){
		synchronized (p) {
			if(i%2==0){
				p.set("周杰伦", "男");
			}else{
				p.set("邓紫棋", "女");
			}
			i++;
		}
	}
}

}
//消费者
class Consumer1 implements Runnable{
public boolean tag=true;
Person1 p;

public Consumer1() {
	super();
	// TODO Auto-generated constructor stub
}

public Consumer1(Person1 p) {
	super();
	this.p = p;
}

public void run() {
	
	// TODO Auto-generated method stub
	//因为主代码都在person类里面完成了，所以这里就没什么代码
	while(tag){
		p.read();
		
	}
}

}

后台线程
后台线程：就是隐藏起来一直在默默运行的线程，直到进程结束。
实现：
setDaemon(boolean on)
特点：
当所有的非后台线程结束时，程序也就终止了同时还会杀死进程中的所有后台线程，也就是说，只要有非后台线程还在运行，程序就不会终止，执行main方法的主线程就是一个非后台线程。
必须在启动线程之前（调用start方法之前）调用setDaemon（true）方法，才可以把该线程设置为后台线程。
一旦main（）执行完毕，那么程序就会终止，JVM也就退出了。
可以使用isDaemon() 测试该线程是否为后台线程（守护线程）。
该案例：开启了一个qq检测升级的后台线程，通过while真循环进行不停检测，当计数器变为100的时候，表示检测完毕，提示是否更新，线程同时结束。
为了验证，当非后台线程结束时，后台线程是否终止，故意让该后台线程睡眠一会。发现只要main线程执行完毕，后台线程也就随之消亡了。
class QQUpdate implements Runnable {
int i = 0;

@Override
public void run() {
	while (true) {

		System.out.println(Thread.currentThread().getName() + " 检测是否有可用更新");
		i++;
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {

			e.printStackTrace();
		}
		if (i == 100) {
			System.out.println("有可用更新，是否升级？");
			break;
		}
	}
}

}
public class Demo9 {
public static void main(String[] args) {
QQUpdate qq = new QQUpdate();
Thread th = new Thread(qq, “qqupdate”);
th.setDaemon(true);
th.start();
System.out.println(th.isDaemon());
System.out.println(“hello world”);
}
}

Thread的join方法
当A线程执行到了B线程Join方法时A就会等待，等B线程都执行完A才会执行，Join可以用来临时加入线程执行
本案例，启动了一个JoinThread线程，main（主线程）进行for循环，当计数器为50时，让JoinThread，通过join方法，加入到主线程中，发现只有JoinThread线程执行完，主线程才会执行完毕.
可以刻意让JoinThread线程sleep，如果JoinThread没有调用join方法，那么肯定是主线程执行完毕，但是由于JoinThread线程加入到了main线程，必须等JoinThread执行完毕主线程才能继续执行。
class JoinThread implements Runnable {

@Override
public void run() {
	int i = 0;
	while (i < 300) {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + " i:" + i);
		i++;
	}
}

}

public class Demo10 {
public static void main(String[] args) throws InterruptedException {
JoinThread jt = new JoinThread();
Thread th = new Thread(jt, “one”);
th.start();
int i = 0;
while (i < 200) {
if (i == 100) {
th.join();
}
System.err.println(Thread.currentThread().getName() + " i:" + i);
i++;

	}
}

}
上述程序用到了Thread类中的join方法，即th.join语句，作用是将th对应的线程合并到嗲用th.join语句的线程中，main方法的线程中计数器到达100之前，main线程和one线程是交替执行的。在main线程中的计数器到达100后，只有one线程执行，也就是one线程此时被加进了mian线程中，one线程不执行完，main线程会一直等待
带参数的join方法是指定合并时间，有纳秒和毫秒级别。