并发编程基础五(线程相关方法2)

123 阅读3分钟
#回顾
1.在java编程语言中,与线程相关的方法主要有:
 1.1.Object.wait/Object.notify/Object/notifyAll
 1.2.Thread.sleep/Thread.join/Thread.yield
2.需要把各个方法的作用和使用场景说清楚,需要用两篇文章进行分享
3.这是第二篇:
	我们关注:sleep/join/yield方法

#考考你
1.你知道sleep方法的作用吗?
2.你知道wait与sleep方法的区别吗?
3.你知道join方法的作用吗?
4.你知道yield方法的作用吗?

案例

方法:sleep

方法简述:

1.让线程进入TIMED_WAITING状态

2.如果线程占有锁对象资源,不会释放锁

package com.anan.thread.threadmethod;

import java.util.Random;
import java.util.concurrent.TimeUnit;

/**
 * 线程方法sleep:
 *  1.让线程进入TIMED_WAITING状态
 *  2.如果线程占有锁对象资源,不会释放锁
 */
public class ThreadMethodSleepDemo {

    // 锁
    public final static Object LOCK = new Object();

    public static void main(String[] args) {
        // 创建Runnable对象
        Runnable r1 = new MyRunnable();

        // 创建两个线程对象
        Thread t1 = new Thread(r1,"thread-0");
        Thread t2 = new Thread(r1,"thread-1");

        // 启动线程
        t1.start();
        t2.start();

    }
}

/**
 * 实现Runnable接口,创建线程
 */
class MyRunnable implements Runnable{
    public void run() {
        System.out.println("【" + Thread.currentThread().getName() + "】准备休眠.");
        // 加锁,演示sleep不释放锁
        synchronized (ThreadMethodSleepDemo.LOCK){
            System.out.println("【" + Thread.currentThread().getName() + "】获取到锁.休眠进行中.");
            int time = 0;
            try {
                Random random = new Random();
                time = random.nextInt(6);
                TimeUnit.SECONDS.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("【" + Thread.currentThread().getName() + "】随机休眠:" +time+ "秒时间到.释放锁.");
        }
        System.out.println("【" + Thread.currentThread().getName() + "】结束休眠.");
    }
}

image.png

方法:join

方法简述:

1.方法join表示在一个线程中,加入另外一个线程 2.被加入线程,会等待【加入线程】执行完成

package com.anan.thread.threadmethod;

import java.util.concurrent.TimeUnit;

/**
 * 线程方法join:
 *      1.如果有线程加入我们,我们就等待加入线程执行完成
 */
public class ThreadMethodJoinDemo {

    public static void main(String[] args) throws InterruptedException{
        // 创建线程对象
        Runnable r1 = new MyRunnable1();
        Thread t1 = new Thread(r1,"thread-0");
        t1.start();

        // join方法
        t1.join();

        System.out.println("主线程main方法执行中.");

    }
}

/**
 * 实现Runnable接口,创建线程
 */
class MyRunnable1 implements Runnable{
    public void run() {
        for(int i = 0; i < 3; i++){
            System.out.println(Thread.currentThread().getName() +
                    "第:【" + i + "】次执行.");

            // 休眠10毫秒
            try {
                TimeUnit.MILLISECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName() + "执行结束.");
    }
}

image.png

方法:yield

方法简述:

1.线程主动让出CPU执行时间

2.孔融让梨,和谐社会大家好

3.需要注意:这只是一种美德,不能对它产生依赖

package com.anan.thread.threadmethod;

/**
 * 线程方法yield:
 *      1.线程主动让出CPU执行时间
 *      2.孔融让梨,和谐社会大家好
 */
public class ThreadMethodYieldDemo {

    public static void main(String[] args) {
        // 创建两个线程
        Runnable r1 = new MyRunnable2();

        Thread t0 = new Thread(r1, "thread-0");
        Thread t1 = new Thread(r1, "thread-1");

        // 线程t0
        t0.start();

        // yield方法,线程t1
        t1.start();
        t1.yield();

    }
}

/**
 * 实现Runnable接口,创建线程
 */
class MyRunnable2 implements Runnable{
    public void run() {
        for(int i = 0; i < 3; i++){
            System.out.println("【" + Thread.currentThread().getName() +
                    "】第:【" + i + "】次执行.");

        }
        System.out.println("【" + Thread.currentThread().getName() +
                "】执行结束.");
    }
}

image.png

总结

1.你知道sleep方法的作用吗?
 1.1.让线程进入TIMED_WAITING状态
 1.2.如果线程占有锁对象资源,不会释放锁
 
2.你知道wait与sleep方法的区别吗?
 2.1.wait方法,让线程进入WAITING状态,或者TIMED_WAITING状态
 2.2.sleep方法,让线程进入TIMED_WAITING状态
 2.3.区别:
 	wait方法,会释放占有的锁对象资源
 	sleep方法,【不】释放占有的锁对象资源
 	
3.你知道join方法的作用吗?
 3.1.join表示在一个线程中,加入另外一个线程
 3.2.被加入线程,会等待【加入线程】执行完成
 
4.你知道yield方法的作用吗?
 4.1.线程主动让出CPU执行时间
 4.2.孔融让梨,和谐社会大家好
 4.3.需要注意:
  	该方法,只是一种美德,我们不应该依赖它