java之12天 多线程 ( 二)

[size=medium][b]线程停止
stop()
interrupt()

[/b][/size]

/**
 * 停止线程 
 *stop方法已经过时 
 *interrupt()  强制
 *
 * 如果停止线程?
 * 只有一种方法,run方法结束
 * 开启多个线程运行,运行代码通常是循环结构
 * 
 * 只要控制住循环,就可以让run方法结束,也就是线程结束.
 * 
 * 特殊情况
 * 当线程处于冻结状态
 * 就不会读取到标记. 那么线程就不会结束
 * 
 * 
 * 当没有指定的方法让冻结的线程恢复到运行的状态时, 这是需要对冻结的线程进行清除,
 * 强制让线程回复到运行状态来,这样就可以操作标记让线程结束.  
 *  interrupt() 会强制唤醒冻结的线程 然后,但是 这种做法是非法的 ,所以就会抛出异常.
 *
 */

class StopThread implements Runnable{
	private boolean flag=true;
	public synchronized void run(){  //需要 run方法运行完  加入  synchronized 和 wait 后 即使 改变 flag 也终止不了线程运行 .这是采用强制 来中断 
		while(flag){
			try {
				wait();   //即使 改变 状态   线程还是没有停止 
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				//e.printStackTrace();
				System.out.println(Thread.currentThread().getName()+"......Exception");
				flag=false;
			}
			System.out.println(Thread.currentThread().getName()+"......run");
		}
	}

	public void changeFlag(){
		flag=false;
	}
}

public class ThreadStopDemo {


	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StopThread st=new StopThread();
		Thread t1=new Thread(st);
		Thread t2=new Thread(st);
		t1.start();
		t2.start();

		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		int num=0;
		while(true){
			if(num++ ==60){
				//st.changeFlag();
				t1.interrupt();
				t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"...."+num);
		}
	}

}

[size=medium][b]线程守护 或者 说后台运行
setDaemon(boolean flag)
[/b][/size]

/**
 * 守护线程
 * setDaemon(boolean flag) ; 用户线程 或者 后台线程  
 * 当所有的前台线程运行完后,后台线程自动关闭
 *
 */
class StopThread implements Runnable{
	private boolean flag=true;
	public synchronized void run(){  //需要 run方法运行完  加入  synchronized 和 wait 后 即使 改变 flag 也终止不了线程运行 .这是采用强制 来中断 
		while(flag){
			/*try {
				//wait();   //即使 改变 状态   线程还是没有停止 
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				//e.printStackTrace();
				System.out.println(Thread.currentThread().getName()+"......Exception");
				flag=false;
			}*/
			System.out.println(Thread.currentThread().getName()+"......run");
		}
	}

	public void changeFlag(){
		flag=false;
	}
}

public class ThreadDaemonDemo {

	public static void main(String[] args) {

		StopThread st=new StopThread();
		Thread t1=new Thread(st);
		Thread t2=new Thread(st);

		t1.setDaemon(true);  //在运行前将 线程标记为后台线程 让它自动 和主线程 争取 CPU 资源
		t2.setDaemon(true);   //加了 守护线程后  ,上面的 wait  下面的 changeFlag() interrupt() 都可以不用了

		t1.start();
		t2.start();

		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		int num=0;
		while(true){
			if(num++ ==60){
				//st.changeFlag();
				//t1.interrupt();
				//t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"...."+num);
		}

		//当主线程 运行完后, 后台线程 自动停止运行.
	}

}

[size=medium][b]线程临时加入 join()[/b][/size]

/**
 * join 
 * 当A线程　执行到　B的线程的join()方法时,A就会等待 ,等 B线程都执行完后,A才会执行.
 * 
 * join: 可以用来临时加入其他线程执行.
 *
 */
class Demo implements Runnable{

	public void run(){

		for(int x=0;x<70;x++){
			System.out.println(Thread.currentThread().getName()+"....");
		}

	}
}

public class ThreadJoinDemo {


	public static void main(String[] args) throws InterruptedException {
		Demo d=new Demo();
		Thread t1=new Thread(d);
		Thread t2=new Thread(d);
		t1.start();
		// t1要申请到 运行中过来, t1 表示要抢夺 CPU的执行权, 此时 主线程 就处于 冻结状态.
		// 只有在 t1 运行结束 后 ,主线程 才能 执行 .
		//t1.join();  

		t2.start();

		t1.join();  // 如果在 加入到这里后   线程中只有 t1  t2 进行交互,  谁的join 主线程就等谁 完后 就只有 t2 和 主线程抢夺CPU资源
		for (int i = 0; i < 80; i++) {
			System.out.println("main...."+i);
		}
		System.out.println("over");

	}

}

[size=medium][b]线程优先级 和 暂停
setPriority(int newPriority)
yield()[/b][/size]

/**
 * setPriority(int newPriority);  //更线程的优先级 ,只有 10 个级别 , 默认为 5
 * 
 * yield(); 暂停现在 执行的线程对象 ,释放执行权, 执行其他线程对象.
 * 
 * 
 *
 */
class Demo implements Runnable{

	public void run(){

		for(int x=0;x<70;x++){
			System.out.println(Thread.currentThread().getName()+"....");
			Thread.yield(); //释放执行权  临时停止  /稍微减少 线程执行的频率 ,让交替次数多点. 尽量达到 和谐状态.
		}

	}
}


public class ThreadYieldDemo {
	public static void main(String[] args) {
		Demo d=new Demo();
		Thread t1=new Thread(d);
		Thread t2=new Thread(d);
		t1.start();
		// t1要申请到 运行中过来, t1 表示要抢夺 CPU的执行权, 此时 主线程 就处于 冻结状态.
		// 只有在 t1 运行结束 后 ,主线程 才能 执行 .
		//t1.join();  
		t2.start();
		t2.setPriority(Thread.MAX_PRIORITY);  //t1.setPriority(6); 也可以 设置优先级
		//t1.join();  // 如果在 加入到这里后   线程中只有 t1  t2 进行交互,  谁的join 主线程就等谁 完后 就只有 t2 和 主线程抢夺CPU资源
		for (int i = 0; i < 80; i++) {
			System.out.println("main...."+i);
		}
		System.out.println("over");

	}

}

[b]常见 多线程应用 简单实例[/b]

public class ThreadDemo {
	public static void main(String[] args) {
		//三个不相关的代码快  这样运行效率滴 如果次数再多点的话就更低了
		new Thread(){
			public void run(){
			for (int i = 0; i < 100; i++) {
				System.out.println("A");
			}}
		}.start();


		for (int i = 0; i < 100; i++) {
			System.out.println("B");
		}

		new Thread(
			new  Runnable(){
				public void run(){
					for (int i = 0; i < 100; i++) {
						System.out.println("C");
					}

				}
			}
		).start();

		//这样 三个线程就可以同时运行了 

		//或则建立类型  
       new Thread(new ThreadTest()).start();

	}

}
class ThreadTest implements Runnable{

	public void run(){
		for (int i = 0; i < 100; i++) {
			System.out.println("C");
		}

	}
}
//这种情况下使用多线程  会提高运行效率