Java并发学习 2: 线程入门知识

我会带着你远行 2022-02-21 00:17 184阅读 0赞

### 1. 什么是线程？ ###

现在操作系统再运行一个程序时，会为其创建一个进程。进程是资源调度的单位，而现代操作系统CPU调度的最小单元是线程，在一个进程里可以创建多个线程，这些线程都拥有各自的计数器，堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在线程上高速切换，让使用者感觉到这些线程在同时执行。

### 2. 多线程的好处和坏处？ ###

优点：多个线程能够同时执行，这将显著提升程序性能，在多核环境下表现得更加明显，此外能更快地响应复杂操作(复杂操作同步进行)。

缺点：过多地创建线程和对线程的不当管理也容易造成问题，如申请/释放线程的损耗已经超过了多线程带来的速度优势。

总结 : 我们为了更好的利用资源，使用多线程，但往往用户的不恰当使用，或者说因为多线程本身的学习难度，造成了多线程下可能造成的损耗。

### 3. 线程优先级。 ###

在操作系统中，线程的优先级高意味着更大可能性分配到申请的资源。在Java中也提供了这样的功能，但操作系统可能会不理会Java对优先级的设定。

### 4. 线程有几种状态？ ###

> 1.  **新建状态**(new) :新创建了一个线程对象
> 2.  **就绪状态**(Runnable): 线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于"可运行线程池"中，变得可运行，只等待获取CPU的使用权，即在就绪状态的进程除CPU之外，其他的运行所需资源都已全部获得。
> 3.  **运行状态**：就绪状态的线程获取了CPU，执行程序代码。
> 4.  **阻塞状态**：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行，知道线程进入就绪状态，才有机会转到运行状态.
>     
>     1.  **等待阻塞**：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自行唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒.
>     2.  **同步阻塞**：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。
>     3.  **其他阻塞**: 运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态，当阻塞结束后，重启转为就绪状态。
> 5.  **死亡状态**: 线程执行完了或者因异常推出了run()方法，该线程结束生命周期。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTYxOTQ4_size_16_color_FFFFFF_t_70][]

### 5. Daemon(守护)线程 ###

守护线程可能较为陌生，但其实我们常用的Java GC本身就是一个Daemon线程，守护线程主要被用作程序中后台调度以及支持性工作，当JVM中不存在非Daemon线程时，那么JVM将会退出。

public class Daemon {
        public static void main(String[] args) {
            Thread thread = new Thread(new DaemonRunner(), "DaemonRunner");
            // 必须在启动线程前，将其设置为Daemon线程，当然默认的线程都是非Daemon线程的。
            thread.setDaemon(true);
            thread.start();
        }
        static class DaemonRunner implements Runnable {
            public void run() {
                try {
                    SleepUtils.second(10);
                } finally {
                    // 在运行后，你会发现这句话没有被打印，因为JVM中不存在非Daemon线程了，所以其已经强制退出了
                    System.out.println("DaemonThread finally run.");
                }
            }
        }
    }

\#\# 3.1 继承 Thread类

// 继承，则Demo1 也成为了一个线程
    public class Demo1 extends Thread {
        // 继承Thread类，需要重写run()方法，告诉这个类需要去坐什么.
        @Override
        public void run() {
            System.out.println(”新出来的线程正在工作“);
        }
       
        public static void main(String[] args) {
            Demo1 d1 = new Demo1();
            // 一个建议，建议此时线程启动，实际上很可能还没启动，需要等到CPU调度。
            d1.start();
            System.out.println(”Main线程工作结束“);
        }
    }

\#\# 3.2 实现 Runnable 接口

/**
     * 这种生成线程任务的方式是面向接口，而不是面向继承的，更被推崇。
     * 优点 ： 解耦
     */
    public class Demo2 implements Runnable{
    
        @Override
        public void run() {
            while (true) {
                System.out.println("thread running ... ");
            }
        }
    
        public static void main(String[] args) {
            // 将Runnable的一个实现类传入
            Thread thread = new Thread(new Demo2());
            // 开启一个新线程
            thread.start();
        }
    }

\#\# 3.3 匿名内部类

匿名内部类本质上还是以上两种方法

继承Thread类

public class Demo3 {
        public static void main(String[] args) {
            // 本质上还是继承了Thread类
            new Thread(){
                public void run() {
                    System.out.println("匿名内部类 run！！！");
                }
            }.start();
        }
    }

实现Runnable接口,

public class Demo3 {
        public static void main(String[] args) {
            // 本质上还是实现了Runnable接口
            new Thread( new Runnable() {
                @Override
                public void run() {
                    System.out.println("匿名内部类，接收一个Runnable接口");
                }
            }
            ){
                
            }.start();
        }
    }

那么如果即继承Thread类，又实现Runnable接口的话，这个对象的run()结果会是谁的呢？

public class Demo3 {
        public static void main(String[] args) {
            // 继承了Thread类
            new Thread(new Runnable() {
                // 为方便描述，我们称这个为：runA
                @Override
                public void run() {
                    System.out.println("Runnable接口的run");
                }
            }){
                // 为方便描述，我们称这个为：runB
                @Override
                public void run() {
                    System.out.println("子类的run");
                }
            }.start();
        }//.. 结果是 ： “子类的run”
    }

原因是因为Runnable的run()需要Thread类的run方法调用，源码如下：

/**
         * target就是传入的Runnable接口对象.
         * 如果传入了Runnable接口，那么使用Runnable接口对象使用的run（）方法。
         */
        @Override
        public void run() {
            if (target != null) {
                target.run();
            }
        }
    // 但是，子类的run()方法会Override父类的run()方法，所以...

\#\# 3.4 实现Callable接口

Callable接口和Runnable接口非常相似.

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class Demo4 implements Callable<Integer> {
        public static void main(String[] args) {
            Demo4 d = new Demo4();
            // FutureTask接口实现一个RunnableFuture接口
            // FutureTask<V> implements RunnableFuture<V>
            // 而RunnableFuture接口 则继承了Runnable, Future<V>两个类，
            // interface RunnableFuture<V> extends Runnable, Future<V>
            // 所以综上，FutureTask本质上就是Runnable的一个子类。
            FutureTask<Integer> task = new FutureTask<>(d);
            Thread t = new Thread(task);
            t.start();
            // 此时线程并未执行
            System.out.println("1");
    
            // 得到线程返回的结果.
            Integer res = null;
            try {
                res = task.get();
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
            System.out.println("2");
            System.out.println("callable的返回结果 " + res);
        }// .. 输出结果：
        // 1
        //  call!!!
        //         2
        //callable的返回结果 100
        
        // 也就是当get()的时候执行call内容/
        @Override
        public Integer call() throws Exception {
            System.out.println("call!!!");
            Thread.sleep(3000);
            // 分贝：
            return 100;
        }
    }

\#\# 3.5 其他线程创建的方式

1. 定时器

- 定时器本质就是一个不断维护时间的线程。

import java.util.Timer;
       import java.util.TimerTask;
       
       public class Demo5 {
           public static void main(String[] args) {
               Timer timer = new Timer();
               // abstract class TimerTask implements Runnable
               // 实现了Runnable接口的抽象类
               timer.schedule(new TimerTask() {
                   @Override
                   public void run() {
                       System.out.println("定时任务");
                   }
               }, 500, 1000);
               // 延时500ms后，每隔1000ms的时候执行一次.
           }
       }// 也有专用的定时框架来实现定时器功能.

2. 线程池的实现

- 线程池和其他池子一样，属于空间换时间，cache。

import java.util.concurrent.Executor;
       import java.util.concurrent.ExecutorService;
       import java.util.concurrent.Executors;
       
       public class Demo6 {
           public static void main(String[] args) {
               // 申请 size == 10 的线程池
               Executor theadPool = Executors.newFixedThreadPool(10);
       
               // 每个线程的名字都会被打印，
               // 但是如果超过10，那么将会出现：每个线程都会出现，但是次数不一定.
               for (int i = 0; i < 1000; i++) {
                   theadPool.execute(new Runnable() {
                       @Override
                       public void run() {
                           // 打印当前线程名
                           System.out.println("线程名为：" + Thread.currentThread().getName());
                           // 我统计的某一次的执行次数
                           // id 次数
                           // 1     347   // 2     380
                           // 3    104   // 4     1
                           // 5     1       // 6    23
                           // 7     39     // 8     103
                           // 9     1       // 10   3
                       }
                   });
               }
           }
       }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTYxOTQ4_size_16_color_FFFFFF_t_70]: /images/20220221/e789a2b4630e45b293f5210677e04af2.png