线程和进程的区别，以及三种多线程的实现方式。

ゝ一纸荒年。 2022-11-17 11:23 200阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70]

### 多线程 ###

*  一、前言
 *  二、进程和线程
 *  2.1进程的介绍
 *  2.2线程的介绍
 *  2.3进程和线程的关系以及区别
 *  三、多线程的实现
 *   *  3.1继承Thread类
     *  3.2实现Runnable接口
     *  3.3实现Callable接口
     *  3.4案例：模拟售票员售票
     *  3.5实现方式的比较
     *  3.6调用start()与run()方法的区别
 *  四、线程的常用方法
 *   *  4.1设置线程的名称
     *  4.2线程休眠
     *  4.3设置线程优先级
     *  4.4合并线程
     *  4.5后台线程
     *  4.6线程让步
 *  五、线程的生命周期
 *  六、银行取钱案例
 *   *  6.1分析和解决
     *  6.2代码实现
     *  6.3输出结果

# 一、前言 #

本文主要是帮助大家理解线程和进程的区别，以及三种多线程的实现方式。

# 二、进程和线程 #

# 2.1进程的介绍 #

进程是对一个程序的运行状态和资源占用（内存，CPU）的描述。  
进程是程序的一个动态过程,它指的是从代码加载到执行完毕的一个完成过程。

进程的特点：  
a.独立性：不同的进程之间是独立的，相互之间资源不共享；  
b.动态性：进程在系统中不是静止不动的，而是在系统中一直活动的；  
c.并发性：多个进程可以在单个处理器上同时进行，且互不影响；

# 2.2线程的介绍 #

线程是进程的组成部分，一个进程可以有多个线程，每个线程去处理一个特定的子任务。

线程的执行是抢占式的，多个线程在同一个进程中可以并发执行，其实就是CPU快速的在不同的线程之间切换，也就是说，当前运行的线程在任何时候都有可能被挂起，以便另外一个线程可以运行。

# 2.3进程和线程的关系以及区别 #

a.一个程序运行后至少有一个进程；  
b.一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义的；  
c.进程间不能共享资源，但线程之间可以；  
d.系统创建进程需要为该进程重新分配系统资源，而创建线程则容易的多，因此使用线程实现多任务并发比多进程的效率高；

# 三、多线程的实现 #

## 3.1继承Thread类 ##

继承自Thread类，Thread类是所有线程类的父类，实现了对线程的抽取和封装。

> 继承Thread类创建并启动多线程的步骤：  
> a.定义一个类，继承自Thread类，并重写该类的run方法，该run方法的方法体就代表了线程需要完成的任务， 因此，run方法的方法体被称为线程执行体；  
> b.创建Thread子类的对象，即创建了子线程；  
> c.用线程对象的start方法来启动该线程；

**代码实现：**

package com.bigdata;
    
     //四个线程:main、线程1、线程2、新线程
            Mythread mythread1 = new Mythread(); //创建线程对象
            mythread1.setName("线程1"); //给线程取名的方式1
            mythread1.start();//启动线程
    
            Mythread mythread2 = new Mythread();
            mythread2.setName("线程2");
            mythread2.start();
            
            Thread thread = Thread.currentThread(); //获取当前线程
            System.out.println(thread);//打印 Thread[main,5,main]
            System.out.println(thread.getName());//打印 main
    
    /**
     * 线程类:继承Thread，并重写该类的run方法
     */
    class Mythread extends Thread{
        
        @Override
        public void run() {
        
            for(int i=0;i<10;i++){
        
                //获取当前线程的名称
                System.out.println(Thread.currentThread().getName()+"hello"+i);
            }
        }
    }

## 3.2实现Runnable接口 ##

> 实现Runnable接口创建并启动多线程的步骤：  
> a.定义一个Runnable接口的实现类，并重写该接口中的run方法，该run方法的方法体同样是该线程的线程执行体；  
> b.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象；  
> c.调用线程对象的start方法来启动该线程；

**代码实现：**

package com.bigdata.thread2;
    
    public class ThreadUsageDemo02 {
        
        public static void main(String[] args) {
        
            //并不是线程对象
            check check = new check();
            /**
             * Thread(Runnable target)
             分配新的 Thread 对象。
             */
            Thread thread1 = new Thread(check);
            thread1.start();
    
            Thread thread2 = new Thread(check);
            thread2.start();
    
        }
    }
    
    class check implements  Runnable{
        
        @Override
        public void run() {
        
            for (int i = 0; i <10 ; i++) {
        
                System.out.println(i);
            }
        }
    }

## 3.3实现Callable接口 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70 1]

> 实现Callable接口创建并启动多线程的步骤：  
> a.定义一个Callable接口的实现类，并定义返回类型和重写该接口中的call方法，该call方法的方法体同样是该线程的线程执行  
> 体  
> b.创建FutureTask对象，创建Callable子类对象，复写call(相当于run)方法，将其传递给FutureTask对象（相当于一 个Runnable）。 创建Thread类对象，将FutureTask对象传递给Thread对象。  
> c.调用start方法开启线程。这种方式可以获得线程执行完之后的返回值。

**代码实现：**

package com.bigdata;
    
    import java.util.concurrent.Callable; //juc java 并发包
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    public class FutureTaskTest {
        
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
    
      
            CallableTest callableTest = new CallableTest();
    
            //通过线程对象创建FutureTask
            FutureTask<Integer> futureTask = new FutureTask<>(callableTest);
    
            Thread thread = new Thread(futureTask , "线程1");
            thread.start();
    
            //获取线程运行的返回值
            Integer i = futureTask .get();
            System.out.println(i);
    
    
    
        }
    
    
    }
    //线程类
    class CallableTest implements Callable<Integer>{
        
    
        @Override
        public Integer call() throws Exception {
        
            int sum=0;
            for(int i=0;i<100;i++){
        
                System.out.println(Thread.currentThread().getName()+":"+i);
                sum+=i;
            }
            return sum;
        }
    }

## 3.4案例：模拟售票员售票 ##

**业务需求：**  
模拟4个售票员售100张票

**代码实现：**

package com.bigdata.thread1;
    
    /**
     * 案例：模拟售票员售票
     */
    public class ThreadTextDemo01 {
        
        public static void main(String[] args) {
        
            //需求：模拟4个售票员售100张票
            SellTickets s1 = new SellTickets();
            SellTickets s2 = new SellTickets();
            SellTickets s3 = new SellTickets();
            SellTickets s4 = new SellTickets();
            s1.start();
            s2.start();
            s3.start();
            s4.start();
        }
    
    }
    class SellTickets extends Thread{
        
        private static int count=100;//总票数
    
        @Override
        public void run() {
        
           //循环售票
            while (count>0){
        
                try {
        
                    Thread.sleep(10);//考虑到CPU性能，故设置了延迟时间
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                count--;
                System.out.println(Thread.currentThread().getName()+"售出了一张票，剩余"+count);
            }
    
        }
    }

**控制台结果：**  
出现了漏票、重票、负值票的情况。  
![在这里插入图片描述][20210409132930680.png]  
![在这里插入图片描述][20210409132955477.png]  
**分析：**  
因为线程在竞争的过程中，出现了漏票、重票、负值票的情况，  
漏票：CPU的切换是非常快的，可能线程1正好执行完count–的时候，线程已经切换到了线程2，此时count–又再执行了一次，导致跳过了一张票没有卖出，  
重票：当线程1恰好正好将要执行count–但还没执行的时候，线程已经切换到了线程2，此时因为线程1并没有进行count–操作，线程2卖出了重复的同一张票以后，才执行了count–，导致出现了同一张票重复销售的情况。  
负值票：当线程1恰好正好将要执行count–但还没执行的时候，线程已经切换到了线程2，此时因为线程1并没有进行count–操作，线程2执行了count–，导致出现了负值票的情况。  
\* 此时，我们需要引入线程锁的概念，以解决线程的同步问题。

## 3.5实现方式的比较 ##

> 实现Runnable接口的方式  
> a.线程类只是实现了Runnable接口，还可以继承其他类【一个类在实现接口的同时还可以继承另外一个类】  
> b.可以多个线程共享同一个target对象，所以非常适合多个线程来处理同一份资源的情况  
> c.弊端：编程稍微复杂，不直观，如果要访问当前线程，必须使用Thread.currentThread()

> 继承Thread类的方式  
> a.编写简单，如果要访问当前线程，除了可以通过Thread.currentThread()方式之外，还可以使用  
> super关键字  
> b.弊端：因为线程类已经继承了Thread类，则不能再继承其他类【单继承】

实际上大多数的多线程应用都可以采用实现Runnable接口的方式来实现【推荐使用匿名内部类】

## 3.6调用start()与run()方法的区别 ##

当调用start()方法时将创建新的线程，并且执行run()方法里的代码，但是如果直接调用start()方法，不会创建新的线程也不会执行调用线程的代码

# 四、线程的常用方法 #

## 4.1设置线程的名称 ##

方式一：  
setName（）

**代码实现：**

Mythread mythread1 = new Mythread(); //创建线程对象
    mythread1.setName("线程1"); //给线程取名

方式二：  
通过有参构造器给线程的name赋值

**代码实现：**

public static void main(String[] args) {
        
            Mythread3 mythread3 = new Mythread3("新线程");//给线程取名的方式2：通过构造方法给线程的name赋值
            mythread3.start();
        }
    
    /**
     * 线程类
     * 给线程取名的方式2：通过构造方法给线程的name赋值
     */
    class Mythread3 extends  Thread{
        
    
        public Mythread3(){
         }
    
       public Mythread3(String name){
        
            super(name);//调用的父类中的Thread(String name)
       }
    
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName());
        }
    }

## 4.2线程休眠 ##

sleep（）使得当前正在执行的线程休眠一段时间，释放时间片，导致线程进入阻塞状态。  
sleep（5000），5000的单位是毫秒，设置了sleep就相当于将当前线程挂起5s,这个操作跟线程的优先级无关， 当对应的时间到了之后，还会再继续执行。

**代码实现：**

//设置线程休眠
    try {
        
    Thread.sleep(1000);
    } catch (InterruptedException e) {
        
     e.printStackTrace();
    }

## 4.3设置线程优先级 ##

setPriority（）可以通过设置优先级来改变线程抢到时间片的概率，优先级高的线程获得较多的执行机会。  
默认情况下，每个线程的优先级都与创建它的父线程具有相同的优先级，例如：main线程具有普通优先级，则由main线程创建的子线程也有相同的普通优先级。

注意：  
所传的参数范围1~10，默认为5，对应的数值越大，说明优先级越高，这个方法的设置一定要在start之前。  
线程的优先级低并不意味着争抢不到时间片，只是抢到时间片的概率比较低而已。

**代码实现：**

Runnable r = new Runnable(){
        
    
    @Override
    public void run() {
        
    }
    };
    Thread t0 = new Thread(r);
    t0.setPriority(8);

## 4.4合并线程 ##

join()在执行原来线程的过程中，如果遇到了合并线程，则优先执行合并进来的线程，执行完合并进来的线程后，再回到原来的任务中，继续执行原来的线程。

特点：  
a.线程合并,当前线程一定会释放cpu时间片,cpu会将时间片分给要Join的线程；  
b.哪个线程需要合并就在当前线程中,添加要合并的线程；  
c.join之前,一定要将线程处于准备状态start；

**代码实现：**

package com.bigdata;
    
    public class JoinFunctionDemo01 {
        
    
        public static void main(String[] args) {
        
            for(int i=0;i<100;i++){
        
                System.out.println(Thread.currentThread().getName()+"--"+i);
                if(i==20){
        
    
                    //启动子线程
                    CustomThread customThread = new CustomThread("线程");
                    customThread.start();
    
                    //合并线程
                    try {
        
                        customThread.join();
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
    
                }
    
    
            }
    
        }
    }
    //线程类
    class  CustomThread extends  Thread{
        
        public CustomThread(){
        }
        public CustomThread(String name){
        
            super(name);
        }
    
        @Override
        public void run() {
        
            for(int i=0;i<100;i++){
        
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }

## 4.5后台线程 ##

setDaemon(true)隐藏起来一直在默默运行的线程，直到进程结束，又被称为守护线程或精灵线程，JVM的垃圾回收线程就是典型的后  
台线程。

特征：如果所有的前台线程都死亡，后台线程会自动死亡，必须要在start之前执行。

**代码实现：**

//设置后台线程
    thread.setDaemon(true); 
    thread.start();

## 4.6线程让步 ##

yield()可以让当前正在执行的线程暂停，但它不会阻塞该线程，他只是将该线程转入就绪状态，完全可能出现的情况是：当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

实际上，当某个线程调用了yield方法暂停之后，只有优先级与当前线程相同，或者优先级比当前线程更高的就绪状 态的线程才会获得执行的机会。

**代码实现：**

public class YieldFunctionDemo01 {
        
    public static void main(String[] args) {
         
    YieldThread t0 = new YieldThread("线程000");
    t0.start();
    YieldThread t1 = new YieldThread("线程111"); t1.start();
    }
    
    }
    class YieldThread extends Thread {
         
    public YieldThread(){
        }
    public YieldThread(String name) {
         
    super(name);
    }
    @Override
    public void run() {
        
       for(int i=0;i<50;i++){
        
                System.out.println(Thread.currentThread().getName()+"=="+i);
                //当i为20时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
                if(i==20){
        
                    //线程暂停，不会让线程进入阻塞状态
                    Thread.yield();
                }
                //第一种情况：（线程1）当执行到20时会CPU时间暂停，这时（线程2）抢到CPU时间并执行。
                //第二种情况：（线程1）当执行到20时会CPU时间暂停，这时（线程1）抢到CPU时间并执行。
       }
    }
    }

# 五、线程的生命周期 #

对于线程，当线程被创建并启动之后，它既不是一启动就进入了执行状态，也不是一直处于执行状态，在线程的生命周期中，他会经历各种不同的状态【在一个进程中，多个线程同时运行，是在争抢CPU时间片】

> New(新生)：线程被实例化，但是还没有开始执行  
> Runnable（就绪）:没有抢到时间片  
> Running（运行）:抢到了时间片，CPU开始处理这个线程中的任务  
> Blocked(阻塞): 线程在执行过程中遇到特殊情况，使得其他线程就可以获得执行的机会，被阻塞的线程会等待合适的时机重新进入就绪状态  
> Dead(死亡):线程终止  
> a.run方法执行完成，线程正常结束【正常的死亡】b.直接调用该线程的stop方法强制终止这个线程  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70 2]

# 六、银行取钱案例 #

有三个人同时去银行取款机取钱，这三个同时操作。设银行共有10000元， 第一人取1500，第二人取2000，第三人取3000，结算银行剩余多少钱？

## 6.1分析和解决 ##

三个人就意味着三个线程，银行那边的取钱应当是一个人去取钱，取完钱，下个人才能取钱。  
我们使用join（）合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞，可以想象成排队。

## 6.2代码实现 ##

/**
     实现有三个人同时去银行取款机取钱，这三个同时操作。设银行共有10000元，
     第一人取1500，第二人取2000，第三人取3000，结算银行剩余多少钱？
     */
        
    public class TestThread {
        
        public static void main(String[] args) {
        
    
            Bank bank = new Bank();
    
            bank.getMoney(1500);
            Thread person1 = new Thread(bank);
            person1.setName("第一个人");
            person1.start();
            try {
        
                person1.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
            bank.getMoney(2000);
            Thread person2 = new Thread(bank);
            person2.setName("第二个人");
            person2.start();
            try {
        
                person2.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            bank.getMoney(3000);
            Thread person3 = new Thread(bank);
            person3.setName("第三个人");
            person3.start();
            try {
        
                person3.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    
    }
    
    class Bank implements Runnable{
        
        int totalMoney=10000;//余额
        int money;//要取出的钱
    
        public void getMoney(int money){
        
            this.money=money;
        }
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName()+"取出："+money);
            totalMoney -=money;
            System.out.println("余额为："+totalMoney);
        }
    }

## 6.3输出结果 ##

![在这里插入图片描述][20210409171300618.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70]: /images/20221022/70e6e89921fb4c8c848472d0bd43668c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70 1]: /images/20221022/afaae255e2a94ae3ba98c5df5d09f10a.png
[20210409132930680.png]: /images/20221022/d2317b1a34c4405cb4b591be24786929.png
[20210409132955477.png]: /images/20221022/fa41b06c103f4f31a401b83656cce4e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQ2MDg0Mw_size_16_color_FFFFFF_t_70 2]: /images/20221022/eb5b437e21e7466fb2b4daaaee76d72b.png
[20210409171300618.png]: /images/20221022/f7d43a27a8114853ad6489e3acad5550.png