java中线程方法总结

1:sleep()线程休眠

//子线程多线程代码块
public void MyThread extends Thread{
    public void run(){
        for(int i = 0; i<100;i++){
            System.out.println(Thread.currentThread.getName()+i);
            try{
                sleep(9000);//此处时间单位是毫秒
            } catch(InterruptExeption e){
                e.printStackTrance();
            }
        }
    }
}

//客户端测试代码
public class SleepTest{
    public ststic void mian(String[] args){
        //创建多线程代码块
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

2:线程优先级设定先测试setPriority()

子线程多线程代码块

public class PriThread1 extends Thread{
    public void run(){
        for(int i = 0; i<100;i++){
            System.out.println(Thread.currentThread.getName()+i);
        }
    }
}
//子线程多线程代码块
public class PriThread2 extends Thread{
    public void run(){
        for(int i = 0; i<100;i++){
            System.out.println(Thread.currentThread.getName()+i);
        }
    }
}

//客户端测试代码
public class PtiThreadTest{
    public static void main(String[] args){
        PriThread1 priThread1  = new PriThread1();
        PriThread2 priThread2  = new PriThread2();
        priThread1.setPriority(1);//优先级从1-  10 数字越大优先级越高，默认为五
        priThread2.setPriority(10)
        priThread1.start();
        priThread2.start();
    }
}

3：合并线程join()

package com.it.methodusage;
/**
 * @Date 2019/8/11 12:05
 * @Created by hfh
 * @Description TODO
 */
public class JoinThread extends Thread {
@Override
    public void run() {
 for (int i = 0; i <= 100;i++) {
        System.out.println(Thread.currentThread().getName()+i);
        }
  	try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
   }
}
 //客户端测试代码
package com.it.methodusage;
 /**
 * @Date 2019/8/11 12:06
 * @Created by hfh
 * @Description TODO
 * 插队join()方法会抛出打断异常
 * 加入后正在执行的代码会停止，等待加进来的方法执行完毕后再回来执行原来的方法
 */
 public class JoinTest {
    public static void main(String[] args) throws InterruptedException {
        JoinThread joinThread = new JoinThread();
        joinThread.start();
        joinThread.join();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+i);
        }
    }
}
 
 //结果：先执行完加入的线程方法 后执行主方法
Thread-099
Thread-0100
main0
main1
main2

4：后台线程setDaemon()

//子线程多线程代码块
package com.it.methodusage;
/**
 * @Date 2019/8/11 14:22
 * @Created by hfh
 * @Description TODO
 */


public class BackStageThread extends Thread {
    @Override
	public void run() {
       	     for (int i = 0; i < 100; i++) {
            	System.out.println(Thread.currentThread().getName()+i);
           	 try {
                	Thread.sleep(10);
            	} catch (InterruptedException e) {
                	e.printStackTrace();
            }
        }
    }
}


//客户端测试
package com.it.methodusage;

/**
 * @Date 2019/8/11 14:24
 * @Created by hfh
 * @Description TODO
 * setDaemon()可以将前台线程转化为后台线程
 * 前台完成后后台就不会在执行
 */
public class BackStageTest {
    public static void main(String[] args) throws InterruptedException {
//常见多线程执行代码对象
        BackStageThread backStageThread = new BackStageThread();
        backStageThread.setDaemon(true);
        backStageThread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程"+i);
            Thread.sleep(1);
        }
    }
}
//结果
Thread-017
主线程96
主线程97
主线程98
主线程99

5：线程让步yiled()

package com.it.methodusage;
/**
 * @Date 2019/8/11 14:36
 * @Created by hfh
 * @Description TODO
 */
 public class YieldThread extends Thread {
	@Override
    	public void run() {
        	for (int i = 0; i < 10; i++) {
           	 System.out.println(Thread.currentThread().getName()+i);
            	Thread.yield();
        	}
    	}
}


//客户端测试
package com.it.methodusage;
/**
 * @Date 2019/8/11 14:49
 * @Created by hfh
 * @Description TODO
 */

public class YiledTest {
	public static void main(String[] args) {
        	YieldThread yieldThread = new YieldThread();
       	 	YieldThread yieldThread1 = new YieldThread();
        	yieldThread.start();
        	yieldThread1.start();
    }
}

//结果
Thread-00
Thread-10
Thread-01
Thread-11
Thread-12

6：打断测试interrupt()

package com.it.methodusage;
/**
 * @Date 2019/8/11 15:13
 * @Created by hfh
 * @Description TODO
 */


public class IntererruptThread extends Thread{
	public void run() {
        	System.out.println("子线程");
        	try {
            	Thread.sleep(30000);
           	 System.out.println("正常苏醒");
        	} catch (InterruptedException e) {
            		System.out.println("被大型");
       		}
        System.out.println("子线程结束");
    }
}

//客户端测试
package com.it.methodusage

import java.io.IOException;

 public class InterruptTest {
    public static void main(String[] args) throws IOException {
 	System.out.println("主线程");
        //自线程对象
        IntererruptThread intererruptThread = new IntererruptThread();
        intererruptThread.start();
        System.out.println("三十秒按任意键结束子程序");
        System.in.read();
        intererruptThread.interrupt();
        System.out.println("主线程结束");
    }
}
 //结果
主线程
三十秒按任意键结束子程序
子线程
主线程结束
被大型
子线程结束


主线程
三十秒按任意键结束子程序
子线程
正常苏醒
子线程结束