05Thread类方法解析

傷城~ 2023-06-17 12:52 31阅读 0赞

# Thread类方法解析 #

## 介绍 ##

`class Thread implements Runnable`，Thread类继承Runnable，重写了run方法

## 1. 构造方法Thread(Runnable target) ##

接收一个Runnable类型的对象，赋值给Thread类属性`private Runnable target;`

## 2. start()/run() ##

`start()`是开启一个线程执行`run()`方法的内容，如果直接调用run()方法不会开启线程，只会执行run()方法的内容。

run方法源码：

@Override
        public void run() { 
            if (target != null) { 
                target.run();
            }
        }

默认情况下：如果target不为空，执行target.run()，也就是构造函数中的Runnable对象

/** * 开启一个线程 */
        @Test
        public void test01() { 
            Thread thread = new Thread();
            //thread.run();//不能开启一个线程，是Runnable的接口的实现
            thread.start();
        }

/** * 1.重写run方法 * * @throws Exception */
        @Test
        public void test02() throws Exception { 
            Thread thread = new Thread() { 
                @Override
                public void run() { 
                    System.out.println("my first thread");
                }
            };
            thread.start();
        }

## 3. stop()终止线程 ##

stop()方法会强制把执行到一半的线程终止，可能会造成数据问题，不推荐使用

@Test
        public void test04() { 
            Thread thread = new Thread() { 
                @Override
                public void run() { 
                    System.out.println("my first thread");
                }
            };
            thread.stop(); //不推荐使用，直接中断线程
        }

## 4. 线程中断 ##

线程中断是一种重要的线程协作机制，并不会立即使线程退出，而是设置一个中断标志，而如何处理，完全由线程自行决定。

与线程中断有关的有三个方法：

public void interrupt()    //中断线程，设置中断标志位
    public boolean isInterrupted() //判断是否中断
    public static boolean interrupted()  //判断是否中断，并清除当前中断状态

下面代码，设置中断标志，程序自己处理退出，若不处理中断，程序也会一直执行下去

@Test    
    	public void test05() throws Exception { 
            Thread thread = new Thread(() -> { 
                while (true) { 
                    //判断线程是否被中断
                    if (Thread.currentThread().isInterrupted()) { 
                        System.out.println("interruted");
                        break;
                    }
                    Thread.yield();
                }
            });
            thread.start();
            Thread.sleep(2000);
            //中断线程
            thread.interrupt();
            thread.join();
        }

## 5. sleep() ##

`public static native void sleep(long millis)`

sleep()方法可以设置让线程休眠若干时间，他会抛出一个`InterruptedException`异常，这个异常不是运行时异常，必须捕获。当线程sleep()时，如果中断，就会抛出这个异常。

**sleep()方法由于中断而抛出异常，它会清除中断标记，故在异常处理中，若自己有捕获中断的逻辑，需要再次设置中断标志**

@Test
        public void test06() throws Exception { 
            Thread thread = new Thread(() -> { 
                while (true) { 
                    if (Thread.currentThread().isInterrupted()) { 
                        System.out.println("interruted");
                        break;
                    }
                    try { 
                        System.out.println("1");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) { 
                        System.out.println("interruted when sleep");
                        //设置中断状态，抛出中断后，这里会清除中断标记位
                        //所以线程不会停止，if判断一直为false
                        Thread.currentThread().interrupt();
                    }
                }
            });
            thread.start();
            Thread.sleep(500);
            thread.interrupt();
            Thread.sleep(8000);
        }

## 6. wait()/notify()/notifyAll() ##

为了支持多线程之间协作，jdk提供了两个非常重要的方法wait()、notify()，这两个方法是Object类中的，也就是所有对象都可以调用。

如果一个线程调用了object.wait()，那么这个线程就会进入object对象的等待队列，这个队列中可能有多个线程，当object.nofity()调用时，会在等待队列中随机选择一个线程将其唤醒，这个选择是随机的。nofityAll()会唤醒等待队列中的所有线程。

object.wait()方法、notify()方法、notifyAll()方法必须在synchronized语句中，需要获得目标对象监视器。wait()方法执行后会释放监视器，wait()方法被唤醒后，还需要等待notify()所在的synchronized语句释放监视器，重新获得object的监视器后，才可以继续执行。

**sleep()方法不会释放任何资源**

@Test
        public void test12() throws Exception { 
            Object object = new Object();
    
            Thread t1 = new Thread(() -> { 
                synchronized (object) { 
                    System.out.println("t1 starting");
                    try { 
                        object.wait();//释放锁 等待唤醒 再获得锁，方可执行
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println("t1 end");
                }
            });
    
            Thread t2 = new Thread(() -> { 
                synchronized (object) { 
                    System.out.println("t2 starting");
                    object.notify();
                    try { 
                        Thread.sleep(3000);
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                    System.out.println("t2 end");
                }
            });
    
            t1.start();
            t2.start();
    
            /** * t1 starting * t2 starting * t2 end * t1 end */
    
            Thread.sleep(5000);
        }

## 7. suspend()/resume() ##

suspend()挂起线程，resume()继续执行，已经不推荐使用。

1.  suspend()在导致线程暂停的同时，并不会释放任何资源，这样会阻塞在相关锁上其它线程的执行
2.  如果resume()意外在suspend()前就执行了，被挂起的线程就会一直挂起，锁也一直不会释放
3.  suspend()执行后被挂起的线程依旧是Runnable状态，这会严重影响我们对系统当前状态的判断

@Test
        public void test07() throws Exception { 
            Object o = new Object();
            Thread thread = new Thread(() -> { 
                synchronized (o) { 
                    try { 
                        Thread.sleep(2000);
                        Thread.currentThread().suspend();
                    } catch (InterruptedException e) { 
                        e.printStackTrace();
                    }
                }
    
            });
    
            thread.start();
            //造成线程还没有暂停，就执行唤醒了，线程会一直暂停下去，不会终止
            //被锁住的资源也将会一直锁住
            thread.resume();
            thread.join();
        }

## 8. join()/yield() ##

线程之间协作的另一种方式

join()会一直阻塞在当前线程，知道目标线程完成，当然可以设置一个最大等待时间。join()的本质是调用线程的wait()方法，被调用线程在退出前会调用notifyAll()方法通知所有等待的线程。所以**不要在Thread对象实例上调用wait()或者notify()等方法，可能会影响系统api工作**

yeild()是让出当前cpu执行权，但是还会去争夺cpu资源，也就是还有可能再次抢到。

## 9. setPriority() ##

设置线程优先级1-10

jdk中默认设置了三种

/**
         * The minimum priority that a thread can have.
         */
        public static final int MIN_PRIORITY = 1;
    
       /**
         * The default priority that is assigned to a thread.
         */
        public static final int NORM_PRIORITY = 5;
    
        /**
         * The maximum priority that a thread can have.
         */
        public static final int MAX_PRIORITY = 10;

## 10. setDaemon() ##

设置是否为后台线程，线程分为后台线程与用户线程，

后台线程比如：垃圾回收线程，jit线程等

后台线程是为用户线程服务的，若用户线程执行完毕，后台线程也会死亡。

@Test
        public void test09() throws Exception {
            Thread t = new Thread(() -> {
                try {
                    while (true) {
                        System.out.println(1);
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            t.setDaemon(true);
            t.start();
        }

## **实时内容请关注微信公众号，公众号与博客同时更新：程序员星星** ##

![实时内容请关注微信公众号，公众号与博客同时更新][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIzMjY0NjI_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIzMjY0NjI_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190220082931212.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIzMjY0NjI=,size_16,color_FFFFFF,t_70