Thread

逃离我推掉我的手 2022-09-03 06:26 70阅读 0赞

**线程和线程之间**

堆内存和方法区内存是共享的，但是栈内存独立，一个线程一个栈。

假设启动10个线程，或有10个栈空间，每个栈和每个栈互不干扰，各自执行各自的，这就是多线程并发。

**启动分支线程两种方式：**

**方式一：**

继承 Thread类，重写run方法（run方法不需要手动调用java虚拟机会自动调用）

class MYThread extends Thread{
        @Override
        public void run() {
            super.run();
        }
    }

启动一个分支线程

public class TEST {
        public static void main(String[] args) {
            // 创建一个分支线程对象
            MYThread myThread = new MYThread();
            myThread.start();
        }
    }

start() 方法的作用是：启动一个分支线程，在JVM中，开辟一个新的栈空间，这段代码，任务完成之后，瞬间就结束了，这段代码的任务只是为了开启一个新的栈空间，只要新的栈空间开辟出来，start() 方法就结束了，线程就启动成功了。启动成功的线程会自动调用run方法，并且run方法在分支栈底部（压栈）。

run方法在分支栈的栈底部，main方法在主栈的栈底部。run和main是平级的。

**方式二：**

**实现Runnable接口**

public class TEST {
        public static void main(String[] args) {
            // 创建线程对象
            Thread thread = new Thread(new MYThread());
            // 启动线程
            thread.start();
        }
    }
    // 编写一个类，实现Runnable接口，实现run方法
    class MYThread implements Runnable{
        @Override
        public void run() {
            System.out.println("1");
        }
    }

// lambda表达式
    public class TEST {
        public static void main(String[] args) {
            // 创建线程对象 lambad
            Thread thread = new Thread(() -> {
                int r = 50;
                for (int i = 0; i < 10000; i++) {
                    System.out.println("子线程线程");
                }
            });
            // 启动线程
            thread.start();
    
            for (int i = 0; i < 10000; i++) {
                System.out.println("main线程");
            }
        }
    }

# **线程的生命周期** #

一共分五个状态

新建状态 -> 就绪状态 -> 运行状态 -> 阻塞状态 -> 死亡状态。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70][]

#  **线程名字** #

**1、获取线程名字**

线程对象.getName()

**2、修改线程对象的名字**

线程对象.setName()

public class Lv20210810 {
        /**
         * 获取线程对象
         * 获取线程对象的名字
         * 修改线程对象
         * @param args
         */
        public static void main(String[] args) {
            MyTread myTread = new MyTread();
            System.out.println(myTread.getName()); // 线程对象默认名字为：Thread-0，以此Thread-1 ··· ···
            myTread.setName("123"); // 修改线程名字
            System.out.println(myTread.getName()); // 123
            myTread.start();
        }
    }
    class MyTread extends Thread {
        @Override
        public void run() {
            System.out.println("子线程执行了");
        }
    }

**3、获取当前线程名字**

Thread t = Thread.currentThread()

上边代码出现在哪，获取的就是当前线程的对象。

例：出现在main方法中，获取的就是当前主线程的对象，出现在子线程里，获取的就是子线程对象。

public static void main(String[] args) {
      System.out.println(Thread.currentThread().getName()); // main
    }

public class Lv20210810 {
        public static void main(String[] args) {
            MyTread myTread = new MyTread();
            myTread.start();
        }
    }
    class MyTread extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()); // Thread-0
        }
    }

# **线程的sleep** #

**static void sleep(long 毫秒) **

Thread.sleep(1000)

线程的阻塞状态。

（1）静态方法  
（2）参数是毫秒数  
（3）作用：让当前线程进入休眠，进入 "阻塞状态"，放弃占有的CPU时间片，让给其他线程使用。

// 3秒钟之后才会打印子线程名称
    public class Lv20210810 
        public static void main(String[] args) {
            MyTread myTread = new MyTread();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myTread.start();
        }
    }
    class MyTread extends Thread {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()); // Thread-0
        }
    }

面试题：

**1、**

**下边代码会不会阻塞 t线程的执行？**

下边考察两个点：

（1）Thread.sleep() 方法在哪里执行，那么当前的线程会阻塞，下边在main方法中执行，那么它会阻塞main方法的执行。  
（2）在java中静态变量可以用类来调用，也可以用对象类调用，但是，java中推荐用类名调用以区别实例方法或实例变量。

下边代码执行结果：先执行 **"子线程执行"**，过3秒钟输出 **"main方法执行了"** 。

public class Lv20210810 {
        public static void main(String[] args) {
            MyTread t = new MyTread();
            t.setName("t");
            t.start();
            try {
                t.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("main方法执行了");
        }
    }
    class MyTread extends Thread {
        @Override
        public void run() {
            System.out.println("子线程执行"); 
        }
    }

# **终止线程休眠** #

**线程对象.interrupt ()**

这种终止方式是靠抛出异常来完成的。

下边代码：先输出 "start" ，三秒钟之后抛出异常，在输出 "end"

public class Lv20210810 {
        public static void main(String[] args) {
            MyTread t = new MyTread();
            t.setName("t");
            t.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 终止名字为t线程的睡眠
            t.interrupt();
        }
    }
    class MyTread extends Thread {
        @Override
        public void run() {
            System.out.println("start");
            try {
                Thread.sleep(1000L * 60 * 60 * 24 * 365) ;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("end");
        }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 1][]

# **合理的终止线程执行** #

加锁的方式

下边代码，三秒钟之后，我们把down改为false，此时会结束掉 myThread线程的执行。

public class Lv20210810 {
        public static void main(String[] args) {
            MyTread myTread = new MyTread();
            myTread.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myTread.down = false;
        }
    }
    class MyTread extends Thread {
        boolean down = true;
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                if(down) {
                    System.out.println(i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    return;
                }
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70]: /images/20220829/1eb78547568d424b87fed2da2d2be34b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzc4MDAx_size_16_color_FFFFFF_t_70 1]: /images/20220829/dfd0df7597ef43629da84ab11ea4db31.png