线程几种方法

线程停止：
stop方法已经过时；
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。

只要控制住循环，就可以让run方法结束，也就是线程结束；

特殊情况：
当线程处于冻结状态时；
就不会读取到标记，那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这是需要对冻结进行清除。
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

 

Thread类中提供interrupt()方法；

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");
			}
			System.out.println(Thread.currentThread().getName()+"....run");
		}
	}
	public void change()
	{
		flag=false;
	}
}
class StopDemo
{
	public static void main(String[] args)
	{
		StopThread s=new StopThread();
		Thread t1=new Thread(s);
		Thread t2=new Thread(s);
		t1.start();
		t2.start();
		int num=1;
		while(true)
		{
			num++;
			if(num==60)
			{
				s.change();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"...."+num);
		}
	}
}

这个程序两个线程将陷入冻结状态，而无法停止。

 

利用interrupt（）

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");
			
		}
	}
}
class StopDemo
{
	public static void main(String[] args)
	{
		StopThread s=new StopThread();
		Thread t1=new Thread(s);
		Thread t2=new Thread(s);
		t1.start();
		t2.start();
		int num=1;
		while(true)
		{
			num++;
			if(num==60)
			{
				t1.interrupt();
				t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"...."+num);
		}
	}
}

 

 

 

守护线程(可以理解为后台线程)

 

setDaemon
将该线程编辑为守护线程或用户线程，当正在运行的线程都是守护线程时，Java虚拟机退出。

该方法必须在启动线程钱调用；

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");
			
		}
	}
}
class ShouHuDemo
{
	public static void main(String[] args)
	{
		StopThread s=new StopThread();
		Thread t1=new Thread(s);
		Thread t2=new Thread(s);
		t1.setDaemon(true);
		t2.setDaemon(true);
		t1.start();
		t2.start();
		int num=1;
		while(true)
		{
			num++;
			if(num==60)
			{
				//t1.interrupt();
				//t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"...."+num);
		}
	}
}

未调用interrupt方法也结束了；

后台线程：

开启后和前台线程共同抢CPU资源，当所有的前台线程全结束后，后台线程自动结束，此例main为前台线程，t1 ， t2为后台线程；

 

 

 

join方法

当A线程执行到了B线程的join方法时，A就会等待，等B线程都执行完，A才会执行

join可以用来临时加入线程执行

 

代码片段：

class JoinDemo
{
	public static void main(String[] args)
	{
		Thread t1=new Thread();
		Thread t2=new Thread();
		t1.start();
		t1.join();
		t2.start();
	}
}

当调用t1.start() 后，出现  t1.join(); ，这时 主线程就释放CPU资源，t1 结束后  ，主线程与t2才共享资源；

 

class JoinDemo
{
	public static void main(String[] args)
	{
		Thread t1=new Thread();
		Thread t2=new Thread();
		t1.start();
		t2.start();
		t1.join();
	}
}

这情景是，开始t1 t2 共享CPU资源，但只要t1结束， 主线程就过来抢CPU资源

 

 

优先级

 

怎么看优先级？

Thread类中有个toString方法覆盖了getName，可以住处优先级，这里就不演示了；

 

优先级从1到10

1: MIN_PRIORITY

5: NORM_PRIORITY

10: MAX_PRIORITY

 

如何设置

 例如

t1.setPriority(Thread.MAX_PRIORITY);   当然括号里也可以写数字

 

 

 

yield方法

暂停正在执行的线程，并执行其他线程；

稍微减缓运行频率；

 

class Yield implements Runnable
{
	public void run()
	{
		for(int i=0;i<60;i++)
		{
			System.out.println(Thread.currentThread().toString()+"...."+i);
			Thread.yield();
		}
	}
}
class YieldDemo
{
	public static void main(String[] args)
	{
		Yield y=new Yield();
		Thread t1=new Thread(y);
		Thread t2=new Thread(y);
		t1.start();
		t2.start();
	}
}

有时会出现，但只有某个时间段，并不会一直出现交替现象；

 

 

 

下面看一种创建多线程的简单方法

class XiancTest
{
	public static void main(String[] args)
	{
		new Thread()
		{
			public void run()
			{
				for(int x=0;x<70;x++)
							System.out.println("++++"+x);
			}
		}.start();
		
		for(int i=0;i<70;i++)
			System.out.println("---"+i);
		Runnable r= new Runnable()
		{
			public void run()
			{
				for(int y=0;y<70;y++)
							System.out.println("=="+y);
			}
		};
		new Thread(r).start();
	}
}

利用匿名内部类，当然也可以自己去创建其他类；