/*
* 停止线程
*
* 1、定义循环结束标记
* 因为线程运行代码一般都是循环,只要控制了循环即可
* 如何停止方法,
* 原理就是,run方法结束
* 开启多线程运行,运行代码通常都是循环结构,
* 只要控制住循环,就可以让run结束,也就是线程结束
* 2、使用interrupt(中断)方法
* 该方法是结束线程的冻结状态,使线程回到运行状态
* 注意:stop 方法已经过时,不在使用。
*
* 特殊情况:
* 当线程处于了冻结状态,
* 就不会读取到标记,那么线程就不会结束。
*
* 当没有指定的方式让冻结的线程恢复到运行状态时,需要对冻结进行清除
* 强制让线程恢复到运行状态中来,这样就可以操作编辑让线程结束。
* Thread 类中提供了该方法: interrupt();
*
* setDaemon();设置为守护线程(后台线程)。
* 1、必须在启动线程前运行。
* 2、【开启后台,前台线程一结束,后头就跟着结束】
*
* 【】
* 【jion】
* 就是让main线程释放执行权的意思,并且直到jion结束,main才能获得执行权
* 当jion前是一个线程时,主线程会在该线程结束后取得执行权
* 当jion前是两个以上的线程时候,主线程放弃执行权后,这两个以上的线程会相互抢夺执行权,
* 一直到jion当前线程结束,主线程才能获取执行权,并参与与剩下的线程相互抢夺中。
* 至于jion当前线程结束前,其他线程能否执行完毕,随机性非常强。
*
* 【】
* 【 优先级】,【线程组】
* setPriority();设置优先级
* yield() 零时释放,遇见该方法就释放执行权
*
*
* 什么时候使用线程
* 当一个程序中,出现多个独立循环的时候,
* 当某些代码,需要被同时执行时,就用单独的线程需要封装。
* 看【】
*/
//【1】
class StopThread implements Runnable{
private boolean flag=true;
public synchronized void run(){
while(flag){
try{
wait();
}
catch(InterruptedException e){
System.out.println(Thread.currentThread().getName()+"....exception");
flag=false;
}
System.out.println(Thread.currentThread().getName()+"....run");
}
}
public void changeFlage(){
flag=false;
}
}
public class D_Th_clossThread {
public static void main(String []args){
StopThread st=new StopThread();
//new Thread(new StopThread() ).start();
Thread t1=new Thread(st);
Thread t2=new Thread(st);
t1.setDaemon(true);//设置为后台线程
t2.setDaemon(true);
t1.start();
t2.start();
int num=0;
while(true)
{
if((num++) ==60){
//st.changeFlage();
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"...."+num);
}
System.out.println("over");
}
}
//【2】
class Demo implements Runnable{
public void run() {
for(int i=0;i<70;i++){
System.out.println(Thread.currentThread().getName()+"..."+i);
}
}
}
/*个人理解,jion 就是让main线程释放执行权的意思,并且知道jion结束,main才能获得执行权
* 当jion前是一个线程时,主线程会在该线程结束后取得执行权
* 当jion前是两个以上的线程时候,主线程放弃执行权后,这两个以上的线程会相互抢夺执行权,
* 一直到jion当前线程结束,主线程才能获取执行权,并参与与剩下的线程相互抢夺中。
* 至于jion当前线程结束前,其他线程能否执行完毕,随机性非常强。
*/
class JoinDemo{
public static void main(String []arge)throws Exception{
Demo d=new Demo();
Thread t1=new Thread(d);
Thread t2=new Thread(d);
t1.start();
//t1.join();
t2.start();
t1.join();
for(int i=0;i<80;i++){
System.out.println("main..."+i);
}
System.out.println("over");
}
}
/* 【3】
* 优先级,线程组,
* setPriority();设置优先级
* yield() 零时释放,遇见该方法就释放执行权
*/
class Demo1 implements Runnable{
public void run() {
for(int i=0;i<70;i++){
System.out.println(Thread.currentThread().getName()+"..."+i);
Thread.yield();//零时释放,遇见该代码就释放执行权
}
}
}
class JoinDemo2{
public static void main(String []arge)throws Exception{
Demo d=new Demo();
Thread t1=new Thread(d);
Thread t2=new Thread(d);
t1.start();
t1.setPriority(Thread.MAX_PRIORITY);//设置优先级为max
t2.start();
t1.join();
for(int i=0;i<80;i++){
System.out.println("main..."+i);
}
System.out.println("over");
}
}
/*【4】
* 设定该类中,出现3个循环,在这种情况下,是只有main一个线程,那么就能挨个运行,ps如果是超大循环。。。
* 在这种情况下,这三个需要被同时运行的代码就可以用线程封装起来。
*/
class ThreadTest{
public static void main(String []args){
//[1] 匿名内部类 使用Thread调用子类把其中一个循环进行封装后,就可以达到2个线程同时运行。
new Thread(){
public void run(){
for(int i=0;i<100;i++){
}
}
}.start();
//[2] 主线程代码快
for(int i=0;i<100;i++){
}
//[3] 和[1] 用其中一种就行
Runnable r=new Runnable(){
public void run(){
for(int i=0;i<100;i++){
}
}
};
new Thread(r).start();
//这样一封装,就能达到3个线程同时运算,达到高效。
}
}
黑马官网: http://edu.csdn.net/heima