线程停止
stop()
interrupt()
线程守护 或者 说后台运行
setDaemon(boolean flag)
线程临时加入 join()
线程优先级 和 暂停
setPriority(int newPriority)
yield()
常见 多线程应用 简单实例
stop()
interrupt()
/**
* 停止线程
*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);
}
}
}
线程守护 或者 说后台运行
setDaemon(boolean flag)
/**
* 守护线程
* 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);
}
//当主线程 运行完后, 后台线程 自动停止运行.
}
}
线程临时加入 join()
/**
* 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");
}
}
线程优先级 和 暂停
setPriority(int newPriority)
yield()
/**
* 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");
}
}
常见 多线程应用 简单实例
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");
}
}
}
//这种情况下使用多线程 会提高运行效率