多线程与并发编程【线程休眠、线程让步、线程联合、判断线程是否存活】(二)-全面详解(学习总结---从入门到深化)

 

 

目录

线程休眠

线程让步

线程联合

Thread类中的其他常用方法

判断线程是否存活

线程的优先级


 

线程休眠

多线程与并发编程【线程休眠、线程让步、线程联合、判断线程是否存活】(二)-全面详解(学习总结---从入门到深化)_第1张图片

 sleep()方法:可以让正在运行的线程进入阻塞状态,直到休眠时间 满了,进入就绪状态。sleep方法的参数为休眠的毫秒数。

public class SleepThread implements Runnable
{
    @Override
    public void run() {     
        System.out.println(Thread.currentThread().getName()+" 线程开始");
    for(int i=0;i<20;i++){
              System.out.println(Thread.currentThread().getName()+" "+i);
                try {
                    //线程休眠1秒
                    Thread.sleep(1000);
               } catch(InterruptedException e) {
                    e.printStackTrace();
               }
           }
      System.out.println(Thread.currentThread().getName()+" 线程结束");
   }
    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread t = new Thread(newSleepThread());
        t.start();
        System.out.println("主线程结束");
   }
}

线程让步

多线程与并发编程【线程休眠、线程让步、线程联合、判断线程是否存活】(二)-全面详解(学习总结---从入门到深化)_第2张图片

 yield()让当前正在运行的线程回到就绪状态,以允许具有相同优先 级的其他线程获得运行的机会。因此,使用yield()的目的是让具有 相同优先级的线程之间能够适当的轮换执行。但是,实际中无法保 证yield()达到让步的目的,因为,让步的线程可能被线程调度程序 再次选中。

 使用yield方法时要注意的几点:

      1 yield是一个静态的方法。

      2 调用yield后,yield告诉当前线程把运行机会交给具有相同优先级的线程。

      3 yield不能保证,当前线程迅速从运行状态切换到就绪状态。

      4 yield只能是将当前线程从运行状态转换到就绪状态,而不能是等待或者阻塞状态。

public class TestyieldThread implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<30;i++){
            if("Thread0".equals(Thread.currentThread().getName())){
                if(i == 0){
                    Thread.yield();
               }
           }
          System.out.println(Thread.currentThread().getName()+" "+i);
       }
   }
    public static void main(String[] args) {
        Thread t1 = new Thread(newTestyieldThread());
        Thread t2 = new Thread(newTestyieldThread());
        t1.start();
        t2.start();
   }
}

线程联合

多线程与并发编程【线程休眠、线程让步、线程联合、判断线程是否存活】(二)-全面详解(学习总结---从入门到深化)_第3张图片

 当前线程邀请调用方法的线程优先执行,在调用方法的线程执行结 束之前,当前线程不能再次执行。线程A在运行期间,可以调用线程 B的join()方法,让线程B和线程A联合。这样,线程A就必须等待线 程B执行完毕后,才能继续执行。

 join方法的使用

join()方法就是指调用该方法的线程在执行完run()方法后,再执行 join方法后面的代码,即将两个线程合并,用于实现同步控制。 

class A implements Runnable{
    private Thread b;
    public A(Thread b){
        this.b = b;
   }
    @Override
    public void run() {
        for(int i=0;i<10;i++){
          System.out.println(Thread.currentThread().getName()+" A "+i);
            if(i == 5){
                try {
                    this.b.join();
               } catch(InterruptedException e) {
                    e.printStackTrace();
               }
           }
            try {
                Thread.sleep(1000);} catch (InterruptedException e){
                e.printStackTrace();
           }
       }
   }
}
class B implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<20;i++){
          System.out.println(Thread.currentThread().getName()+" B "+i);
            try {
                Thread.sleep(1000);
           } catch (InterruptedException e){
                e.printStackTrace();
           }
       }
   }
}
public class TestJoinThread {
    public static void main(String[] args) {
        Thread t1 = new Thread(new B());
        Thread t = new Thread(new A(t1));
        t.start();
        t1.start();
 for(int i=0;i<10;i++){
          System.out.println(Thread.currentThread().getName()+" "+i);
            if(i ==2){
                try {
                    t.join();
               } catch(InterruptedException e) {
                    e.printStackTrace();
               }
           }
            try {
                Thread.sleep(1000);
           } catch (InterruptedException e){
                e.printStackTrace();
           }
       }
   }
}

线程联合案例

需求: 实现爸爸让儿子买烟。

/**
* 儿子买烟线程
*/
class SonThread implements Runnable{
    @Override
    public void run() {
        System.out.println("儿子出门买烟");
        System.out.println("儿子买烟需要10分钟");
        for(int i=0;i<10;i++){
            System.out.println("第"+i+"分钟");
            try {
                Thread.sleep(1000);
 } catch (InterruptedException e){
                e.printStackTrace();
           }
       }
        System.out.println("儿子买烟回来了");
   }
}
/**
* 爸爸抽烟线程
*/
class FatherThread implements Runnable{
    @Override
    public void run() {
        System.out.println("爸爸想抽烟,发现烟抽完了");
        System.out.println("爸爸让儿子去买一包红塔山");
        Thread t = new Thread(new SonThread());
        t.start();
        System.out.println("等待儿子买烟回来");
        try {
            t.join();
       } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("爸爸出门找儿子");
            System.exit(1);
       }
  System.out.println("爸爸高兴的接过烟,并把零钱给了儿子");
   }
}
public class TestJoinDemo {
    public static void main(String[] args) {
        System.out.println("爸爸和儿子买烟的故事");
        Thread t = new Thread(new FatherThread());
        t.start();
   }
}

Thread类中的其他常用方法

获取当前线程名称

方式一 this.getName()获取线程名称,该方法适用于继承Thread实现多线 程方式。

class GetName1 extends Thread{
    @Override
    public void run() {
        System.out.println(this.getName());
   }
}

方式二 Thread.currentThread().getName()获取线程名称,该方法适用于 实现Runnable接口实现多线程方式。

class GetName2 implements Runnable{
    @Override
    public void run() {
      System.out.println(Thread.currentThread().getName());
   }
}

设置线程的名称

方式一 通过构造方法设置线程名称。

class SetName1 extends Thread{
    public SetName1(String name){
        super(name);
   }
    @Override
    public void run() {
        System.out.println(this.getName());
   }
}
public class SetNameThread {
    public static void main(String[] args) {
        SetName1 setName1 = new SetName1("SetName1");
        setName1.start();
   }
}

方式二 通过setName()方法设置线程名称。

class SetName2 implements Runnable{
    @Override
    public void run() {
      System.out.println(Thread.currentThread().getName());
   }
}
public class SetNameThread {
    public static void main(String[] args) {
        Thread thread = new Thread(new SetName2());
        thread.setName("SetName2");
        thread.start();
   }
}

判断线程是否存活

多线程与并发编程【线程休眠、线程让步、线程联合、判断线程是否存活】(二)-全面详解(学习总结---从入门到深化)_第4张图片

 isAlive()方法: 判断当前的线程是否处于活动状态。 活动状态是指线程已经启动且尚未终止,线程处于正在运行或准备 开始运行的状态,就认为线程是存活的。

class Alive implements  Runnable{
    @Override
    public void run() {
        for(int i=0;i<4;i++){
          System.out.println(Thread.currentThread().getName()+" "+i);
            try {
                Thread.sleep(500);
           } catch (InterruptedException e){
                e.printStackTrace();
           }
       }
   }
}
public class TestAliveThread {
    public static void main(String[] args) {
        Thread thread = new Thread(newAlive());
        thread.setName("Alive");
        thread.start();
      System.out.println(thread.getName()+" "+thread.isAlive());
        try {
            Thread.sleep(4000);
       } catch (InterruptedException e) {
            e.printStackTrace();
       }
      System.out.println(thread.getName()+""+thread.isAlive());
   }
}

线程的优先级

多线程与并发编程【线程休眠、线程让步、线程联合、判断线程是否存活】(二)-全面详解(学习总结---从入门到深化)_第5张图片

 什么是线程的优先级

每一个线程都是有优先级的,我们可以为每个线程定义线程的优先 级,但是这并不能保证高优先级的线程会在低优先级的线程前执 行。线程的优先级用数字表示,范围从1到10,一个线程的缺省优 先级是5。 Java 的线程优先级调度会委托给操作系统去处理,所以与具体的操 作系统优先级有关,如非特别需要,一般无需设置线程优先级。

注意

线程的优先级,不是说哪个线程优先执行,如果设置某个线程 的优先级高。那就是有可能被执行的概率高。并不是优先执 行。

 线程优先级的使用

使用下列方法获得或设置线程对象的优先级。

1 int getPriority();

2 void setPriority(int newPriority);

注意:优先级低只是意味着获得调度的概率低。并不是绝对先 调用优先级高的线程后调用优先级低的线程。

class Priority implements Runnable{
    private int num = 0;
    private  boolean flag = true;
    @Override
    public void run() {
        while(this.flag){
          System.out.println(Thread.currentThread().getName()+" "+num++);
       }
   }
    public void stop(){  
        this.flag = false;
   }
}
public class PriorityThread {
    public static void main(String[] args)throws Exception {
        Priority p1 = new Priority();
        Priority p2 = new Priority();
        Thread t1 = new Thread(p1,"线程1");
        Thread t2 = new Thread(p2,"线程2");
        System.out.println(t1.getPriority());
        //Thread.MAX_PRIORITY = 10
        t1.setPriority(Thread.MAX_PRIORITY);
        //Thread.MAX_PRIORITY = 1
        t2.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
        Thread.sleep(1000);
        p1.stop();
        p2.stop();
   }
}

你可能感兴趣的:(Java基础深化和提高,java,jvm,多线程与并发编程)