java 线程《三》Thread 方法

柔光的暖阳◎ 2021-09-19 14:58 342阅读 0赞

\#列表  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70]

## 测试线程是否处于活动状态。 上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法。 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 1]

package com.javabase;
    
    //实现多线程的第二种方式： 实现runnable接口
    public class RunableDemo3 implements Runnable {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println(Thread.currentThread().getName());
    		RunableDemo3 r1=new RunableDemo3();
    		//new了Thread以后， 线程状态：新建
    		Thread t1=new Thread(r1);
    		t1.setName("自定义线程名字-t1");
    		//最高10， 最低1， 默认5
    		//优先级别越高，抢到CPU的概率越大
    		t1.setPriority(10);
    		//执行start以后，线程状态：就绪
    		//new了Thread以后， 线程状态：新建
    		Thread t2=new Thread(r1);
    		t2.setName("自定义线程名字-t2");
    		//最高10， 最低1， 默认5
    		t2.setPriority(1);
    		
    		
    		Thread t3=new Thread(r1);
    		t3.setName("自定义线程名字-t3");
    		//最高10， 最低1， 默认5
    		//优先级别越高，抢到CPU的概率越大
    		t3.setPriority(10);
    	
    		t2.start();
    		t1.start();
    		t3.start();
    	}
    
    	//执行run方法，线程状态：运行
    	public void run() {
    		// TODO Auto-generated method stub
    		System.out.println("RunableDemo>>run");
    		System.out.println(Thread.currentThread().getName());
    		/**
    		 * Thread.yield( )方法：
    
    			使当前线程从执行状态（运行状态）变为可执行态（就绪状态）。cpu会从众多的可执行态里选择，也就是说，当前也就是刚刚的那个线程还是有可能会被再次执行到的，并不是说一定会执行其他线程而该线程在下一次中不会执行到了。
    			
    			用了yield方法后，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
    		 */
    		Thread.yield();
    		System.out.println("RunableDemo>>run--2");
    		System.out.println(Thread.currentThread().getName());
    	}
    
    }

main  
RunableDemo>>run  
自定义线程名字-t3  
RunableDemo>>run  
自定义线程名字-t1  
RunableDemo>>run–2  
自定义线程名字-t3  
RunableDemo>>run–2  
自定义线程名字-t1  
RunableDemo>>run  
自定义线程名字-t2  
RunableDemo>>run–2  
自定义线程名字-t2

# wait和notify #

*  wait和notify 是Object上的方法
 *  sleep是Thread类里面的方法
 *  sleep不会释放锁
 *  wait会释放锁
 *  多线程中，所有的锁，都是指对象锁

package com.zz.thread;
    
    /**
     * @Description: java类作用描述
     * @Author: Bsea
     * @CreateDate: 2019/9/21$ 20:35$
     */
    public class Test5 {
    
        public static void main(String[] args) {
            Test5 test5=new Test5();
            Thread t1=new Thread(
                new Runnable(){
    
                    @Override
                    public void run() {
                        test5.t1();
                    }
                }
                );
    
            Thread t2=new Thread(
                    new Runnable(){
    
                        @Override
                        public void run() {
                            test5.t2();
                        }
                    }
            );
    
            t1.start();
            t2.start();
        };
        public synchronized  void t1(){
            try {
                System.out.println("开始等待");
                wait();
                System.out.println("被叫醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public synchronized  void t2(){
            System.out.println("开始叫醒");
            notify();
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70]: /images/20210726/ae2d7dc874cf449f95ffba331d57602b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gzNTYzNjM_size_16_color_FFFFFF_t_70 1]: /images/20210726/7977b2c330484ba489c988cad7ccd316.png