多线程(一):认识和创建一个线程

你的名字 2023-10-02 20:37 61阅读 0赞

#### 认识和创建一个线程 ####

*  一.进程与线程
 *   *  1.进程
     *   *  (1).什么是进程
         *  (2).创建进程
     *  2.线程
     *  3.进程和线程的关系
     *  4.为什么要使用多线程
 *  二.创建一个线程
 *  1.创建线程的方式
 *   *  (1).继承Thread类
     *  (2)实现Runnable接口
     *  (3)实现Callable接口
 *  2.线程的基本使用及优势
 *   *  (1).两个变量同时相加所用时间

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

## 一.进程与线程 ##

### 1.进程 ###

#### (1).什么是进程 ####

> 进程(Process)是计算机中的程序关于某数据集合上的`一次运行活动`，是系统进行`资源分配`和`调度`的基本单位，是操作系统结构的基础。

进程是关于某数据集合上的一次运行活动,**可以把进程看作程序的一次运行**,  
在操作系统内部,进程又是操作系统进行**资源分配**的**基本单位**。

#### (2).创建进程 ####

`Ctrl + Alt + Delete`打开任务管理器,显示电脑上运行着的进程

![在这里插入图片描述][81b3d07b1956463fb2adeb4127f04582.png]  
打开一个记事本,再次查看进程  
![在这里插入图片描述][db137a2beeff4e6692fed8df63dfac08.png]  
再次打开一个记事本  
![在这里插入图片描述][afbd5bf12ac64c568a377960e17355ba.png]  
观察发现,有两个记事本的进程同时运行,并且相互之间互不影响,并发执行.

> 每一个进程,都有一个`进程控制块抽象(PCB Process Control Block)`,每一个`PCB`,都代表一个运行着的程序,也就是进程

### 2.线程 ###

> 一个线程就是一个 “执行流”. 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 “同时” 执行着多份代码.

线程有时也被称为轻型进程,线程中基本不包含系统资源,只有一点必不可少的,保证线程运行的资源  
一个进程有一个或多个线程组成，彼此间完成不同的工作，同时执行，称为多线程。

### 3.进程和线程的关系 ###

*  进程是包含线程的. 每个进程至少有一个线程存在，即主线程。
 *  进程和进程之间不共享内存空间. 同一个进程的线程之间共享同一个内存空间.
 *  进程是系统分配资源的最小单位，线程是系统调度的最小单位。
 *  同一进程的多个线程之间可以共享进程资源

### 4.为什么要使用多线程 ###

*  创建线程比创建进程更快.
 *  销毁线程比销毁进程更快.
 *  调度线程比调度进程更快.

开启多个线程,比开进程开销小,对CPU的利用率大,执行速度更快.  
![在这里插入图片描述][f9901329b42546cab08cc1842e6aeb9f.png]

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

## 二.创建一个线程 ##

## 1.创建线程的方式 ##

### (1).继承Thread类 ###

创建测试类继承Thread类并重写run方法

class CreateThread extends Thread{
        
    
        @Override
        public void run() {
        
            System.out.println("运行run方法.");
        }
    }

创建完毕之后,可以通过Thread方法创建一个线程

public class CreateThread extends Thread{
        
    
        @Override
        public void run() {
        
            System.out.println("运行run方法.");
        }
    
        public static void main(String[] args) {
        
            //实例化子类对象创建对象
            Thread thread1 = new CreateThread();
            thread1.start();
    
            //将CreateThread实例对象作为Thread的参数
            CreateThread createThread = new CreateThread();
            Thread thread2 = new Thread(createThread);
            thread2.start();
    
       		//3.匿名内部类
            Thread thread3 = new Thread(){
        
                @Override
                public void run() {
        
                    System.out.println("匿名内部类创建一个线程.");
                }
            };
            thread3.start();
        }
    }

程序运行结果  
![在这里插入图片描述][1fbf4dd1093a48af9eae781426da18aa.png]  
可以看到,程序的运行结果不是按照顺序执行.这取决于创建的3个进程谁能更快的获得CPU的资源,谁就可以先运行,所以,涉及到多线程的程序中,程序的运行结果往往是不唯一的

### (2)实现Runnable接口 ###

> 观察Thread的源码  
> ![在这里插入图片描述][4300e3920153467e83d9a4bc4e9611e7.png]  
> 我们发现,Thread实现了Runnable接口  
> ![在这里插入图片描述][2c36c34cf58c4272915b44ddf7db2675.png]  
> 在Runnable接口中,只有一个run()方法,Thread也实现了run方法,  
> ![在这里插入图片描述][99ae1d5351d2404cbc25ed81f5b01475.png]  
> 可以将一个Runnable对象传入Thread中,所以,我们可以自己实现Runnable接口,并将Runnable的实例对象当作参数传入Thread中

最大的好处:Java是单继承的,但是可以实现多个接口,避免了继承Thread类而出现Java语言单继承的局限性

// 继承 Runnable
    public class CreateRunnable implements Runnable{
        
        @Override
        public void run() {
        
            System.out.println("执行run方法..");
        }
    
        public static void main(String[] args) {
        
            CreateRunnable createRunnable = new CreateRunnable();
            Thread t1 = new Thread(createRunnable);
            t1.start();
    
            Thread t2 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println("匿名内部类..");
                }
            });
            t2.start();
        }
    }

### (3)实现Callable接口 ###

> 除此之外,还可以通过Callable接口创建对象,这种方法比较特殊,此处演示使用方法,原理单独出文解释,地址:[Callable源码详解][Callable]

import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;
    
    public class CreateCallable implements Callable<String> {
        
        @Override
        public String call() throws Exception {
        
            return "call 方法.";
        }
    
        public static void main(String[] args) throws Exception {
        
    
            // 获取Callable实例
            Callable<String> callable = new CreateCallable();
    
            //由于Thread不接收Callable实例,需要一个中间类包装一下
            FutureTask<String> futureTask = new FutureTask<>(callable);
            Thread t = new Thread(futureTask);
            t.start();
    
            //获取结果
            //如果结果没生成,就等待
            String result = futureTask.get();
            System.out.println(result);
        }
    }

## 2.线程的基本使用及优势 ##

### (1).两个变量同时相加所用时间 ###

顺序执行:

public static void serial(){
        
            long start = System.currentTimeMillis();
            int a = 0;
            for (long i = 0; i < count; i++) {
        
                a++;
            }
            int b = 0;
            for (long i = 0; i < count; i++) {
        
                b++;
            }
            long end = System.currentTimeMillis();
            System.out.println("消耗时间"+(end-start)+"毫秒");
        }

多线程执行

private static void concurrency(){
        
            long start = System.currentTimeMillis();
    
            Thread thread1 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    int a = 0;
                    for (long i = 0; i < count; i++) {
        
                        a++;
                    }
                }
            });
    
            Thread thread2 = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    int b = 0;
                    for (long i = 0; i < count; i++) {
        
                        b++;
                    }
                }
            });
            thread1.start();
            thread2.start();
    
            try {
        
                thread1.join();
                thread2.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
    
    
            long end = System.currentTimeMillis();
            System.out.println("消耗时间"+(end-start)+"毫秒");
        }

main方法调用运行程序

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

> 可以看到,两个线程并行计算,所用时间比串行计算快了接近一半注意:线程的创建销毁也要消耗一定时间

> 系列文章❀❀❀[多线程(二):Thread类的常见方法][Thread]❀❀❀❀❀❀[多线程(三):synchronized解决线程不安全][synchronized]❀❀❀

[81b3d07b1956463fb2adeb4127f04582.png]: https://img-blog.csdnimg.cn/81b3d07b1956463fb2adeb4127f04582.png
[db137a2beeff4e6692fed8df63dfac08.png]: https://img-blog.csdnimg.cn/db137a2beeff4e6692fed8df63dfac08.png
[afbd5bf12ac64c568a377960e17355ba.png]: https://img-blog.csdnimg.cn/afbd5bf12ac64c568a377960e17355ba.png
[f9901329b42546cab08cc1842e6aeb9f.png]: https://img-blog.csdnimg.cn/f9901329b42546cab08cc1842e6aeb9f.png
[1fbf4dd1093a48af9eae781426da18aa.png]: https://img-blog.csdnimg.cn/1fbf4dd1093a48af9eae781426da18aa.png
[4300e3920153467e83d9a4bc4e9611e7.png]: https://img-blog.csdnimg.cn/4300e3920153467e83d9a4bc4e9611e7.png
[2c36c34cf58c4272915b44ddf7db2675.png]: https://img-blog.csdnimg.cn/2c36c34cf58c4272915b44ddf7db2675.png
[99ae1d5351d2404cbc25ed81f5b01475.png]: https://img-blog.csdnimg.cn/99ae1d5351d2404cbc25ed81f5b01475.png
[Callable]: http://t.csdn.cn/diqQV
[94b9070444e14ca4ba59fef09ddef6a5.png]: https://img-blog.csdnimg.cn/94b9070444e14ca4ba59fef09ddef6a5.png
[Thread]: http://t.csdn.cn/fhcbd
[synchronized]: http://t.csdn.cn/wpV76