线程几种方法

线程停止：

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();
}
}

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