线程操作API

Posted 2020-10-15 小哥z

1、Thread.currendThead

Thread的静态方法currendThead方法可以用于获取运行当前代码片段的线程。

    public static void main(String[] args){
        System.out.println(Thread.currentThread());
        //输出 Thread[main,5,main]
    }

 

2、获取线程信息

Thread提供了获取线程信息的相关方法

public class testThread implements Runnable{

    public void run(){
        for(int i=0;i<5;i++){
                System.out.println(i);
        }    
    }
    public static void main(String[] args){
        testThread t1=new testThread();
        Thread t=new Thread(t1);
        Thread  t2=new Thread("自定义的名字");
        t.start();
        System.out.println(t.getId());//返回线程标识符   8
        System.out.println(t.getName());//返回线程名字    Thread-0
        System.out.println(t.getPriority());//返回线程优先级   5
        System.out.println(t.getState());//返回线程状态        BLOCKED
        System.out.println(t.isAlive());//线程是否处于活动状态   false
        System.out.println(t.isDaemon());//线程是否是守护线程    false
        System.out.println(t.isInterrupted());//线程是否是已中断  false
        
    }

}

3、线程优先级

线程切换时由线程调度控制的，我们无法通过代码来干涉，但是我们可以通过提高线程优先级来最大程度的改善线程获取时间片的几率。

线程的优先级划分为10级，分别为1-10（1最低，10最高），

 

public class testThread { 
    public static void main(String[] args) { 
            Thread t1 = new MyThread1(); 
            Thread t2 = new MyThread2(); 
            t1.setPriority(10); 
            t2.setPriority(1); 
            t2.start(); 
            t1.start(); 
    } 
} 

class MyThread1 extends Thread { 
    public void run() { 
            for (int i = 0; i < 5; i++) { 
                    System.out.println("线程1第" + i + "次执行！"); 
            } 
    } 
} 
class MyThread2 extends Thread{ 
    public void run() { 
            for (int i = 0; i < 5; i++) { 
                    System.out.println("线程2第" + i + "次执行！"); 
   
            } 
    } 
}

线程1第0次执行！
线程1第1次执行！
线程1第2次执行！
线程2第0次执行！
线程1第3次执行！
线程2第1次执行！
线程1第4次执行！
线程2第2次执行！
线程2第3次执行！
线程2第4次执行！

说明：优先级高的线程获取CPU资源的概率较大，优先级低的并非没机会执行。

但在java中，优先级高的好像并没有太大的优势，按理说实际的应该明显优于1级的。

4、守护线程

守护线程和普通线程在表现上没什么区别，我们只需要通过Thread提供的方法来设定即可；

void.setDaemon(boolean)，当参数为true时该线程为守护线程。

当线程中指剩下守护线程时，所有守护线程强制终止。

  Daemon的作用是为其他线程的运行提供服务，比如说GC线程。其实User Thread线程和Daemon Thread守护线程本质上来说去没啥区别的，唯一的区别之处就在虚拟机的离开：如果User Thread全部撤离，那么Daemon Thread也就没啥线程好服务的了，所以虚拟机也就退出了。

5、sleep方法

Thread的静态方法

sleep用于使当前线程进入阻塞状态，该方法会使线程进入阻塞状态指定毫秒，当阻塞指定毫秒后，当前线程重新进入Runnable状态，等待分配时间片（重新分配）

该方法声明抛出一个InterruptException,必须捕获异常

不释放锁，不出让系统资源，其他线程不能占用CPU

public class testThread { 
    public static void main(String[] args) { 
        Thread t = new Thread(){
            public void run(){
                while(true){
                    System.out.println("测试守护线程");
                    try{
                        Thread.sleep(1000);
                    }catch(InterruptedException e){

                    }
                }
            }
        };
        t.setDaemon(true);
        t.start();
        try{
            Thread.sleep(5000);
        }catch(InterruptedException e1){    
        }
        //进程中所有前台进程结束了，后台线程强制结束
        System.out.println("main进线程结束了");
    } 
} 

测试守护线程
测试守护线程
测试守护线程
测试守护线程
测试守护线程
测试守护线程
main进线程结束了

6、yield方法

Thread的静态方法，该方法用于使当前线程主动让出档次CPU时间片回到Runnable状态，等待分配时间片

public class Testyield extends Thread{
    public Testyield(){
         
    }
    public Testyield(String name){
        super(name);
    }
    public  void run(){
        for(int i=0;i<5;i++){
 //           System.out.println(getName()+"  "+i);
            if (i==2){
                System.out.println(getName()+"------"+getPriority());
                Thread.yield();
            }
        }
    }
    public static void main(String[] args){
        Testyield y1=new Testyield("高级");
        y1.setPriority(Thread.MAX_PRIORITY);
        y1.start();
        Testyield y2=new Testyield("低级");
        y2.setPriority(Thread.MIN_PRIORITY);
        y2.start();
    }
}

 

7、join方法

让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作

该方法声明抛出IntertuptException.

 

public class JoinTest {
    public static void main(String [] args) throws InterruptedException {
        ThreadJoinTest t1 = new ThreadJoinTest("test_1");
        ThreadJoinTest t2 = new ThreadJoinTest("test_2");
        t1.start();
        /**join的意思是使得放弃当前线程的执行，并返回对应的线程，例如下面代码的意思就是：
         程序在main线程中调用t1线程的join方法，则main线程放弃cpu控制权，并返回t1线程继续执行直到线程t1执行完毕
         所以结果是t1线程执行完后，才到主线程执行，相当于在main线程中同步t1线程，t1执行完了，main线程才有执行的机会
         */
        t1.join();
        t2.start();
    }

}
class ThreadJoinTest extends Thread{
    public ThreadJoinTest(String name){
        super(name);
    }
    @Override
    public void run(){
        for(int i=0;i<5;i++){
            System.out.println(this.getName() + ":" + i);
        }
    }
}

test_1:0
test_1:1
test_1:2
test_1:3
test_1:4
test_2:0
test_2:1
test_2:2
test_2:3
test_2:4