Java多线程——多线程常用方法的使用

快来打我* 2021-12-07 13:13 413阅读 0赞

## Java多线程——多线程常用方法的使用 ##

###   Java多线程的常用方法基本分为：获取当前线程的操作，线程休眠sleep()方法，线程让步yield()方法，等待其他线程终止join()方法，线程停止的一系列方法。 ###

### 一、获取当前线程的操作 ###

####   1、获取当前线程： Thread.currentThread(); ####

####     需要注意的是： 当一个线程A开启后，调用其他线程类B的普通方法时，此时的线程还是线程A， 当一个线程A直接调用另一个线程类B的run()方法，就和调用普通方法没有区别。 ####

>   **举个栗子说明run()和start()有十分明显的区别**

package com.xiaoaxiao.test.thread_test.book_test;
    		
    		/**
    		 * Created by xiaoaxiao on 2019/7/16
    		 * Description: run()和start()不一样！！！
    		 */
    		
    		class MyThread1 extends Thread{
    		
    		    @Override
    		    public void run() {
    		        try {
    		            System.out.println("run threadName="+Thread.currentThread().getName()+" begin");
    		            Thread.sleep(2000);
    		            System.out.println("run threadName="+Thread.currentThread().getName()+" end");
    		        } catch (InterruptedException e) {
    		            e.printStackTrace();
    		        }
    		    }
    		}
    		
    		public class ThreadTest2 {
    		
    		    public static void main(String[] args) {
    		        MyThread1 mt = new MyThread1();
    		        System.out.println("begin ="+System.currentTimeMillis());
    		//        mt.run();
    		        mt.start();
    		        System.out.println("end ="+System.currentTimeMillis());
    		    }
    		}

若调用mt.run()，输出结果为：
    				begin =1563329164153
    				run threadName=main begin
    				run threadName=main end
    				end =1563329166155
    		若调用mt.start()，输出结果为：
    				begin =1563329194123
    				end =1563329194124
    				run threadName=Thread-0 begin
    				run threadName=Thread-0 end

####   2、获取当前线程的名字：Thread.currentThread().getName() ####

####    而获取当前对象的名字（只在Thread的继承类中出现）：this.getName() ####

####   3、获取当前线程的唯一标识：Thread.currentThread().getId() ####

### 二、线程休眠sleep()方法—单位为毫秒(ms) ###

####   线程休眠是指 让当前线程暂缓执行，等到了预计时间后再恢复执行。`线程休眠`会`立即交出CPU，但是不会释放锁`。 ####

####   sleep()的流程：运行状态->sleep()->阻塞状态->sleep()的时间结束后->就绪状态->系统调度->运行状态。 ####

####    虽然sleep()在指定时间可以从运行状态->(阻塞状态)->就绪状态，但是处于就绪状态时，需要经过系统的调度才能到达运行状态，具体的系统调度是随机的（由CPU进行控制），这就导致了每次sleep()的时间不相同（是有差异的）。 ####

####   sleep()可能会抛出InterruptedException受查异常，需要对异常进行处理。 ####

>   **sleep()立即交出CPU，不会释放锁。**

>   *举个栗子*

package com.xiaoaxiao.test.thread_test;
    		
    		/**
    		 * Created by xiaoaxiao on 2019/7/12
    		 * Description: 测试thread常用的方法——sleep、
    		 */
    		
    		class MyRunnable2 implements Runnable{
    		
    		    @Override
    		    public void run() {
    		        for(int i=0;i<3;i++){
    		            System.out.println(Thread.currentThread().getName());
    		            // sleep()
    		            try {
    		                Thread.sleep(1000);
    		            } catch (InterruptedException e) {
    		                e.printStackTrace();
    		            }
    		        }
    		    }
    		}
    		
    		public class threadMethodTest1 {
    		
    		    public static void main(String[] args) {
    		        MyRunnable2 myRunnable2 = new MyRunnable2();
    		        Thread thread1 = new Thread(myRunnable2,"A");
    		//        Thread thread2 = new Thread(myRunnable2,"hello");
    		        Thread thread2 = new Thread(myRunnable2,"B");
    		        Thread thread3 = new Thread(myRunnable2,"C");
    		        thread1.start();
    		        thread2.start();
    		        thread3.start();
    		    }
    		}

输出结果：
    				B
    				C
    				A
    				A
    				C
    				B
    				B
    				C
    				A

### 三、线程让步yield()方法——运行态（running）->就绪态(runnable) ###

####   线程让步是指 暂停执行当前的线程对象，并执行其他线程，`yield()方法`会让当前线程`交出CPU`（`不一定立即交出CPU`），`不会释放锁`。 ####

####   yield()方法无法控制具体交出CPU的时间，并且yield()方法只能让`拥有相同优先级的线程`有获取CPU的机会 ####

>   **yield()会交出CPU（不一定立即交出），不会释放锁。**

>   *举个栗子*

package com.xiaoaxiao.test.thread_test;
    		
    		/**
    		 * Created by xiaoaxiao on 2019/7/12
    		 * Description: 测试thread常用的方法——yield
    		 */
    		
    		class MyRunnable2 implements Runnable{
    		
    		    @Override
    		    public void run() {
    		        for(int i=0;i<10;i++){
    		            System.out.println(Thread.currentThread().getName());
    		
    		            // yield()
    		            Thread.yield();
    		
    		        }
    		    }
    		}
    		
    		public class threadMethodTest1 {
    		
    		    public static void main(String[] args) {
    		        MyRunnable2 myRunnable2 = new MyRunnable2();
    		        Thread thread1 = new Thread(myRunnable2,"A");
    		        Thread thread2 = new Thread(myRunnable2,"B");
    		        Thread thread3 = new Thread(myRunnable2,"C");
    		        
    		        thread1.start();
    		        thread2.start();
    		        thread3.start();
    		    }
    		}

输出结果：
    				A
    				A
    				A
    				B
    				B
    				C
    				C
    				C
    				B

### 四、等待其他线程终止join()方法 ###

####   等待其他线程终止是指主线程等待子线程执行完成之后再结束。（主线程（或者某个线程）中若调用了子线程（或者是另外一个线程）的join()方法就必须得等该子线程run()方法结束，主线程才能继续执行） ####

####    join()方法只是对Object提供的wait()做了一层包装而已。 （join在内部使用`wait()`方法进行等待），执行wait(long)方法后，当前线程的`锁会被释放`，其他线程就可以调用此线程中的同步方法了。 ####

####    join()方法的执行流程与sleep()类似：运行状态->join()->阻塞状态->join()中断->就绪状态->系统调度->运行状态。 ####

####   join()可能会抛出InterruptedException受查异常，需要对异常进行处理。 ####

>   **join()会释放锁。**

>   *举个栗子*

package com.xiaoaxiao.test.thread_test;
    		
    		import java.text.DateFormat;
    		import java.text.SimpleDateFormat;
    		import java.util.Date;
    		
    		/**
    		 * Created by xiaoaxiao on 2019/7/12
    		 * Description: 测试thread常用的方法——join
    		 */
    		
    		class MyRunnable3 implements Runnable{
    		
    		    @Override
    		    public void run() {
    		        try {
    		            System.out.println("主线程睡眠前时间");
    		            threadMethodTest2.printTime();
    		            Thread.sleep(1000);
    		            System.out.println(Thread.currentThread().getName());
    		            System.out.println("睡眠结束时间");
    		            threadMethodTest2.printTime();
    		        } catch (InterruptedException e) {
    		            e.printStackTrace();
    		        }
    		    }
    		}
    		
    		public class threadMethodTest2 {
    		
    		    public static void main(String[] args) throws InterruptedException {
    		        MyRunnable3 myRunnable3 = new MyRunnable3();
    		        Thread threadA = new Thread(myRunnable3,"子线程A");
    		        System.out.println("代码开始");
    		        threadA.start();
    		        // 调用子线程的join方法，当主线程执行到这一步了，
    		        // 一定会等到子线程中所有内容全部执行完，主线程才会继续往下执行
    		        threadA.join();
    		        System.out.println(Thread.currentThread().getName());
    		        System.out.println("代码结束");
    		    }
    		
    		    public static void printTime(){
    		        Date date = new Date();
    		        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		        String time = format.format(date);
    		        System.out.println(time);
    		    }
    		}

输出结果为：
    		代码开始
    		主线程睡眠前时间
    		2019-09-27 16:56:26
    		子线程A
    		睡眠结束时间
    		2019-09-27 16:56:27
    		main
    		代码结束

####   还可以使用join(long)设置最长等待时间（单位：ms），若主线程等待long秒后，无论子线程会不会结束，此时join()中断，主线程进入就绪状态。 ####

class Join extends Thread{
    	    @Override
    	    public void run() {
    	        try {
    	            System.out.println("begin Timer="+System.currentTimeMillis());
    	            Thread.sleep(5000);
    	            System.out.println("end Timer="+System.currentTimeMillis());
    	        } catch (InterruptedException e) {
    	            e.printStackTrace();
    	        }
    	    }
    	}
    	
    	public class JoinTest {
    	
    	    public static void main(String[] args) {
    	        Thread thread = new Join();
    	        thread.start();
    	        try {
    	            thread.join(2000);
    	            System.out.println("main end Timer:"+System.currentTimeMillis());
    	        } catch (InterruptedException e) {
    	            e.printStackTrace();
    	        }
    	
    	    }
    	}
    
    	//	打印结果
    	begin Timer=1569575039934
    	end Timer=1569575041934
    	main end Timer:1569575041934

### 五、线程停止的一系列方法 ###

####   1、设置标记位（flag）停止线程——推荐（好写） ####

>    *在线程类内部设置一个标记位flag并由这个flag对线程类的执行进行控制，在线程类的外部对flag进行修改，从而实现外部对类内部的停止*。

package com.xiaoaxiao.test.thread_test;
    		
    		/**
    		 * Created by xiaoaxiao on 2019/7/12
    		 * Description: 测试thread常用的方法——线程停止-设置标记符
    		 */
    		
    		class MyRunnable4 implements Runnable{
    		
    		    // 设置一个标记符
    		    private Boolean flag = true;
    		
    		    @Override
    		    public void run() {
    		        int i=1;
    		        // 将该标记符当做线程持续进行的条件
    		        while (flag){
    		            try {
    		                Thread.sleep(1000);
    		            } catch (InterruptedException e) {
    		                e.printStackTrace();
    		            }
    		            System.out.println("这是第"+i+"次执行"+"线程名称为："
    		            	+Thread.currentThread().getName());
    		            i++;
    		        }
    		    }
    		
    		    public void setFlag(Boolean flag) {
    		        this.flag = flag;
    		    }
    		}
    		
    		public class threadMethodTest3 {
    		    public static void main(String[] args) throws InterruptedException {
    		        MyRunnable4 myRunnable4 = new MyRunnable4();
    		        Thread thread = new Thread(myRunnable4);
    		        thread.start();
    		        Thread.sleep(5000);
    		        // 主线程睡眠5s后将flag设置为false，
    		        // 当子线程再次访问是，flag已经变为false
    		        myRunnable4.setFlag(false);
    		        // 调用子线程的join，让主线程等待子线程执行完成后再执行
    		        thread.join();
    		        System.out.println("代码结束");
    		    }
    		}

####   2、调用Thread类的stop()方法强制停止线程，该方法不安全，已经被Deprecated（废弃）了。 ####

>   *该方法之所以不安全主要是会造成数据的不一致。*

while(flag){          //按照第一种停止方式，即便在x=3后，flag变为了false，
    								//y依旧能被赋值为4
    				x=3;
    				y=4;
    		}                          //而如果在x=3后直接stop()，则y就不会被赋值为4了

####   3、调用Thread类的interrupt()方法——系统设置标志位 ####

#####     ①interrupt()方法只是将线程状态置为中断状态而已，它不会中断一个正在运行的线程，此方法只是给线程传递一个中断信号，程序可以根据此信号来判断是否需要终止。（使用isInterrupted()判断中断状态） #####

#####     ②当线程中使用wait()、sleep()、join()导致此线程阻塞，则interrupt()会在线程中抛出InterruptException，并且将线程的中断状态`由true置为false`。 #####

######      PS:无论是在sleep()过程中，interrupt()，还是在interrupt()过程中，sleep()，都会抛出InterruptedException异常，并将interrupt中断状态置为false（sleep()和interrupt只要相遇就会出异常，其他两者同理） ######

#####     ③interrupt()中断线程 #####

######      a）线程中没有wait(),sleep(),join()，调用interrupt只是将线程中断状态设置为true。 ######

######      b）线程中有wait(),sleep(),join()，调用interrupt会抛出InterruptException并将线程中断状态由true置为false，在catch块中捕获该异常，然后退出 ######

>   **举个栗子,sleep()对interrupt()的影响**

package com.xiaoaxiao.test.thread_test.book_test;
    		
    		/**
    		 * Created by xiaoaxiao on 2019/7/16
    		 * Description: sleep()对Interrupt()的影响
    		 *              无论是在sleep()过程中，interrupt()
    		 *              还是在interrupt()过程中，sleep()
    		 *              都会抛出InterruptedException异常，并将interrupt状态置为false
    		 */
    		
    		class MyThread2 extends Thread{
    		
    		    @Override
    		    public void run() {
    		        super.run();
    		
    		        try {
    		            for(int i=0;i<1000000;i++){
    		                System.out.println("i="+(i+1));
    		            }
    		            System.out.println("run begin");
    		            Thread.sleep(200000);
    		            System.out.println("run end");
    		        } catch (InterruptedException e) {
    		            System.out.println("先停止，再遇到sleep，interrupt状态为："
    		            		+this.isInterrupted());
    		            e.printStackTrace();
    		        }
    		    }
    		}
    		
    		public class InterruptTest {
    		
    		    public static void main(String[] args) {
    		        MyThread2 mt = new MyThread2();
    		
    		        mt.start();
    		        mt.interrupt();
    		        System.out.println("end!");
    		    }
    		}