Java-多线程2020年

怼烎@ 2022-12-27 02:12 160阅读 0赞

### 文章目录 ###

*  一、多线程概述
 *  二、实现多线程的方式
 *   *  1.继承Thread类
     *  2.实现Runnable接口
     *  3.实现Callable接口
     *  4.三种实现方式的对比
 *  三、多线程的常用方法
 *  四、线程优先级

--------------------

# 一、多线程概述 #

多线程是指用软件或者硬件上实现多个线程并发执行的技术。  
具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

并发和并行

*  并行：在同一时刻，有多个指令在多个CPU上同时执行。
 *  并发：在同一时刻，有多个指令在单个CPU上交替执行。

进程和线程

*  进程：正在运行的程序。
    
     *  独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。
     *  动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。
     *  并发性：任何线程都可以同其他进程一起并发执行。
 *  线程：是进程中的单个顺序控制流，是一条执行路径。
    
     *  单线程：一个进程如果只有一条执行路径，则称为单线程程序。
     *  多线程：一个进程如果有多条执行路径，则称为多线程程序。

# 二、实现多线程的方式 #

## 1.继承Thread类 ##

实现步骤

*  定义一个类MyThread继承Thread类
 *  在MyTHread类中重写run()方法
 *  创建MyThread类的对象
 *  启动线程

public class Test{
        
        public static void main(String[] args) {
        
            MyThread my1 = new MyThread();
            MyThread my2 = new MyThread();
    
            my1.start();
            my2.start();
        }
    }
    class MyThread extends Thread {
        
        @Override
        public void run() {
        
            for (int i = 0; i < 100; i++) {
        
                System.out.println(i);
            }
        }
    }

注意点：

*  为什么要重写run()方法？  
    因为run()是用来封装被线程执行的代码。
 *  run()方法和start()方法的区别？  
    run()：封装线程执行的代码，直接调用，相当于普通方法的调用。  
    start()：启动线程，然后由JVM调用此线程的run()方法。

## 2.实现Runnable接口 ##

Thread构造方法

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Thread(Runnable target)</td> 
   <td>分配一个新的Thread对象</td> 
  </tr> 
  <tr> 
   <td>Thread(Runnable target, String name)</td> 
   <td>分配一个新的Thread对象</td> 
  </tr> 
 </tbody> 
</table>

实现步骤

*  定义一个类MyRunnable实现Runnable接口
 *  在MyRunnable类中重写run()方法
 *  创建MyRunnable类的对象
 *  创建Thread类的对象，把MyRunnable对象作为构造方法的参数
 *  启动线程

public class Test {
        
        public static void main(String[] args) {
        
            MyRunnable my = new MyRunnable();
            Thread t1 = new Thread(my);
            Thread t2 = new Thread(my);
    
            t1.start();
            t2.start();
        }
    }
    
    class MyRunnable implements Runnable {
        
        @Override
        public void run() {
        
            for (int i = 0; i < 100; i++) {
        
                System.out.println(i);
            }
        }
    }

## 3.实现Callable接口 ##

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>V call()</td> 
   <td>计算结果，如果无法计算结果，则抛出一个异常</td> 
  </tr> 
  <tr> 
   <td>Futrue Task(Callable&lt;V&gt; callable)</td> 
   <td>创建一个FutureTask，一旦运行就执行给定的Callable</td> 
  </tr> 
  <tr> 
   <td>V get()</td> 
   <td>如有必要，等待计算完成，然后获取其结果</td> 
  </tr> 
 </tbody> 
</table>

实现步骤

*  定义一个类MyCallable实现Callable接口
 *  在MyCallable类中重写call()方法
 *  创建MyCallable类的对象
 *  创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
 *  创建Thread类的对象，把FutrueTask对象作为构造方法的参数
 *  启动线程
 *  再调用get方法，就可以获取线程结束之后的结果

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    
    public class Test {
        
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            MyCallable mc = new MyCallable();
            FutureTask<String> ft = new FutureTask<>(mc);
            Thread t1 = new Thread(ft);
    
            t1.start();
            String s = ft.get();
            System.out.println(s);
        }
    }
    
    class MyCallable implements Callable<String> {
        
        @Override
        public String call() throws Exception {
        
            for (int i = 0; i < 100; i++) {
        
                System.out.println(i);
            }
            return "结果";
        }
    }

## 4.三种实现方式的对比 ##

实现Runnable、Callable接口

*  优点：扩展性强，实现该接口的同时还可以继承其他的类
 *  缺点：编程相对复杂，不能直接使用Thread类的方法  
    继承Thread类
 *  优点：编程比较简单，可以直接使用Thread类中的方法
 *  缺点：扩展性较差，不能再继承其他的类

# 三、多线程的常用方法 #

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>void run()</td> 
   <td>在线程开启后，此方法将被调用执行</td> 
  </tr> 
  <tr> 
   <td>void start()</td> 
   <td>使此线程开始执行，Java虚拟机会调用run()方法</td> 
  </tr> 
  <tr> 
   <td>void setName(String name)</td> 
   <td>将此线程的名称更改为等于name参数</td> 
  </tr> 
  <tr> 
   <td>String getName()</td> 
   <td>返回此线程的名称</td> 
  </tr> 
  <tr> 
   <td>Thread currentThread()</td> 
   <td>返回对当前正在执行的线程对象的引用</td> 
  </tr> 
  <tr> 
   <td>static void sleep(long millis)</td> 
   <td>使当前正在执行的线程停留指定的毫秒数</td> 
  </tr> 
  <tr> 
   <td>void setDaemon(boolean on)</td> 
   <td>将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出</td> 
  </tr> 
 </tbody> 
</table>

# 四、线程优先级 #

线程调度

*  分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
 *  抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些（Java使用的此模型）

随机性

*  假如计算机只有一个CPU，那么CPU在某一时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的。

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>final int getPriority()</td> 
   <td>返回此线程的优先级</td> 
  </tr> 
  <tr> 
   <td>final void setPriority(int newPriority)</td> 
   <td>更改此线程的优先级，线程默认优先级是5，范围是：1~10</td> 
  </tr> 
 </tbody> 
</table>

--------------------