线程和进程你真的了解吗？快来看看全面的解析和线程的代码

最新推荐文章于 2024-06-14 15:02:13 发布
最新推荐文章于 2024-06-14 15:02:13 发布
阅读量1.5k 收藏 27
点赞数 54
文章标签： java 开发语言 idea jvm 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z122899/article/details/135168175
版权

（本篇文章全面的释义了线程和进程；为了方便大家熟练的掌握，内容中引入了详细的代码；欢迎大家学习讨论和批评指正）

进程的概念

操作系统(OS)中并发(同时)执行的多个程序任务

进程的特点

  • 宏观并行,微观串行

在一个时间段内,CPU会将时间段划分为若干个时间片,一个时间片是能被一个程序拥有,且只有拥有时间片的程序才能执行自身内容,所以当时间片的划分足够细小,交替频率足够快,就会形成并行的假象,时间上仍然是串行.

线程的概念

  • 是进程的基本组成部分

是进程中并发执行的多个任务

线程的特点

  • 宏观并行,微观串行

一个时间片只能被一个进程拥有,一个进程一次又只能执行一个线程. 由于进程之间交替执行,所以线程之间必定也是交替执行

多线程

  • 只存在多线程,不存在多进程

正在执行中的程序才叫进程,其他的都是等待执行的程序

无论是否拥有时间片,线程任务都叫线程

线程执行的组成

  1. 时间片

    • CPU调度分配, 线程争抢拥有

  2. 数据

    • 堆: 堆共享
    • 栈: 栈独立

  3. 代码

    • 书写逻辑

线程的创建

  1. 继承Thread, 重写run方法

    public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <=100 ; i++) {
            System.out.println(i);
        }
    }
    
}

    package com.by.test;

import com.by.thread.MyThread;

public class Test1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();

        t1.start();
        t2.start();
        /*t1.run();
        t2.run();*/

        System.out.println("main结束");
    }
}

  2. 实现Runnable,重写run方法. 在Thread对象的构造中传入任务对象

    package com.by.dao.impl;

/**
 * 线程任务
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i=1;i<=100;i++) {
            System.out.println(i);
        }
    }
}

    package com.by.test;

import com.by.dao.impl.MyRunnable;

import javax.print.attribute.standard.RequestingUserName;

public class Test2 {
    public static void main(String[] args) {
        /*//先创建任务对象
        Runnable r = new MyRunnable();
        //将任务对象传入线程对象
        Thread t1 = new Thread(r);*/
	//任务只会执行一次时,可以通过匿名内部类或者lambda简化书写
       Thread t1=new Thread(new Runnable() {
           @Override
           public void run() {
               for (int i = 1; i <=100 ; i++) {
                   System.out.println("t1:: "+i);
               }
           }
       });

       Thread t2=new Thread(()->{
               for (int i = 101; i <=200 ; i++) {
               System.out.println("t2> "+i);
           }
       });

        t1.start();
       t2.start();


    }
}

更推荐使用第二种创建方式: 更符合类的单一职责,将线程对象的创建与线程任务的书写分离,更有利于后期的维护

使用

  1. 当开启多个线程之后, 线程之间会争抢时间片,拿到时间片的线程执行自身内容,其他线程无法执行,只能继续尝试争抢时间片,直到线程内容执行结束,才会脱离争夺队列
  2. 主函数也成为主线程,其一定是首个拥有时间片的线程
  3. 当开启多个线程之后,JVM执行结束的标志将从主函数执行结束转换为所有线程执行结束
  4. 开启线程需要调用线程对象.start()方法

线程状态

基础状态

在这里插入图片描述

等待状态

  • 也称为阻塞状态

  1. sleep()

    • Thread.sleep(毫秒数): 使当前线程释放自身时间片, 进入有限期休眠状态,在休眠时间内,该线程无法争抢时间片,休眠结束之后,才可以进入到就绪状态
      • 1秒=1000毫秒
    • 该方法需要处理非运行时异常, run方法不可上抛异常,所以必须通过try-catch处理解决
    Thread t1=new Thread(new Runnable() {
           @Override
           public void run() {
               //让当前线程休眠3秒钟
               try {
                   Thread.sleep(3000);
               } catch (InterruptedException e) {
                   System.out.println("休眠异常");
               }
               for (int i = 1; i <=100 ; i++) {
                   System.out.println("t1:: "+i);
               }
           }
       });

  2. join()

    • 线程对象.join(): 使调用者线程在当前线程之前执行, 当前线程只有等调用者线程执行结束进入死亡状态之后才有可能回到就绪状态.
    • 该方法需要处理非运行时异常,run方法无法上抛,必须通过try-catch处理
    package com.by.test;

public class Test3 {
    public static void main(String[] args) {
        //以下代码执行顺序:t1->t2->t3
        Thread t1=new Thread(()->{
            for (int i = 0; i < 30; i++) {
                System.out.println("t1:  "+i);
            }
        });

        Thread t2=new Thread(()->{
            //使t1线程在t2线程之前执行
            try {
                t1.join();
            } catch (InterruptedException e) {
                System.out.println("join失败");
            }
            for (int i = 101; i < 130; i++) {
                System.out.println("t2>"+i);
            }
        });

        Thread t3=new Thread(()->{
            try {
                t2.join();
            } catch (InterruptedException e) {
                System.out.println("join失败");
            }
            for (char i = 65; i <=90; i++) {
                System.out.println("t3::"+i);
            }
        });


        t1.start();
        t2.start();
        t3.start();
    }
}

sleep和join的区别?

  1. sleep方法进入的是有限期等待状态,join方法进入的是无限期等待状态
  2. sleep是静态方法,可以直接通过类名调用,join是非静态方法,必须通过线程对象调用

线程池

前言: 当一个任务需要多次执行时,如果将任务放置于线程对象Thread中,会浪费内存空间导致不合理的并发,线程池可以解决该问题

作用

管理盛放线程任务, 将需要执行的任务提交执行,任务结束之后池与任务并不会立即销毁,任务对象会回到池中等待下次执行,直到线程池关闭,内部任务才会失效

创建-API

  1. ExecutorService: 线程池接口

    • submit(线程任务对象): 提交线程任务使其执行
    • shutdown(): 关闭线程池

  2. Executors: 线程池工具类,用来获取线程池对象

    • newCachedThreadPool(): 获取一个不固定并发数量的线程池对象
    • newFixedThreadPool(int ):获取一个固定并发数量的线程池对象

    不固定并发数量的线程池: 所有提交到池中的任务都会同时并发

    固定并发数量的线程池: 对应并发数量的任务先并发执行,超出的任务需要等待执行,等池中执行的任务结束让位之后,超出部分的任务才会进入池中执行

线程任务

  1. Runnable: run()

    • 无返回值,不能上抛异常
    package com.by.test;

import com.by.dao.impl.MyRunnable;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test4 {
    public static void main(String[] args) {
        //获取一个不固定并发数量的线程池
       // ExecutorService es1 = Executors.newCachedThreadPool();
        ExecutorService es1 = Executors.newFixedThreadPool(2);

        Runnable r1=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    System.out.println("r1>>"+i);
                }
            }
        };
        Runnable r2=new Runnable() {
            @Override
            public void run() {
                for (int i = 50; i < 100; i++) {
                    System.out.println("r2:::"+i);
                }
            }
        };
        //提交任务执行
        es1.submit(r1);
        es1.submit(r2);
        es1.submit(r2);

        //关闭线程池
        es1.shutdown();
    }
}

  2. Callable: call()

    • 有返回值,可以上抛异常,默认上抛Exception
    • 返回值会存放于一个Future对象中,可以通过Future对象.get()获取内部的返回值
    Callable<返回值类型> c1=new Callable<返回值类型>() {
            @Override
            public 返回值类型 call() throws Exception {
               //...
                return 值;
            }
        };

    package com.by.test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test5 {
    public static void main(String[] args) throws Exception {
        //创建线程池
        ExecutorService es = Executors.newCachedThreadPool();
        //线程任务1: 计算1-100的和并返回
        Callable<Integer> c1=new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum=0;
                for (int i = 0; i < 101; i++) {
                    sum += i;
                }
                return sum;

            }
        };
        //提交任务执行并接收
        Future<Integer> f =es.submit(c1);
        System.out.println(f.get());

        System.out.println(es.submit(c1).get());

        //关闭线程池
        es.shutdown();
    }
}

线程安全问题

  • 当多个线程同时访问同一个临界资源时,原子操作可能被破坏,会导致数据丢失, 就会触发线程安全问题
    • 临界资源: 被多个线程同时访问的对象
    • 原子操作: 线程访问临界资源的过程中不可更改和缺失的操作

互斥锁

  • 每个对象都默认拥有互斥锁, 该锁默认不开启.
  • 当开启互斥锁之后,线程想要访问对象,则在需要拥有时间片的基础上也拥有锁标记,锁标记只能被一个线程拥有,拥有时间片和锁标记的线程才能执行自身内容,在此期间,其他线程只能等正在执行的线程执行结束释放锁标记和时间片之后才能进入就绪状态
  • synchronized: 开启互斥锁的关键字
同步方法

  • 思路: 在被线程同时访问的方法上加锁

    访问修饰符 synchronized 返回值类型 方法名(参数列表){
    
}

    package com.by.util;

import java.util.ArrayList;
import java.util.List;

/**
 * 工具类-操作集合属性
 */
public class MyList {
    private List<Integer> list = new ArrayList<>();

    /**
     * 给集合属性添加元素
     * @param n 添加的元素值
     synchronized: 同步方法
     */
    public synchronized void insert(int n){
        list.add(n);
    }
    /**
     * 查看集合内容
     */
    public void query(){
        System.out.println("集合长度: " + list.size());
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+"  ");
        }
    }

}
同步代码块

  • 思路: 让参与临界资源对象访问的线程自身加锁

    synchronized(临界资源对象){
    //需要被认定为原子操作的代码
}

  • 使用: 所有访问同一临界资源的线程都需要同时添加同步代码块

    package com.by.test2;

import com.by.util.MyList;

public class TestMyList {
    public static void main(String[] args)throws Exception {
        //创建两个线程,同时操作工具类,线程1负责往集合中添加元素1-5,线程2负责往集合中添加元素6-10
        //添加结束之后查看集合内容
        //创建工具类对象
        MyList m = new MyList();
        Thread t1=new Thread(()->{
            for (int i = 1; i <=5 ; i++) {
                synchronized (m) {
                    m.insert(i);
                }
            }
        });

        Thread t2=new Thread(()->{
            for (int i = 6; i <=10 ; i++) {
                synchronized (m) {
                    m.insert(i);
                }
            }
        });

        t1.start();
        t2.start();
        //使t1和t2线程先进行添加操作
        t1.join();
        t2.join();

        //查看集合元素
        m.query();
    }
}


/*
* 张三上厕所
* 李四上厕所
*
* 原子操作: 脱裤子-->蹲下来-->上厕所-->擦屁股-->穿裤子-->冲水-->走人
*
*临界资源: 厕所-坑位
*
*解决方式1:给厕所大门加锁
*解决方式2:自己给坑位加锁
* 
*
* */
区别
  1. 同步方法: 线程执行需要同时争抢时间片和锁标记,写法简单但效率较慢
  2. 同步代码块: 线程只需要争抢时间片, 开启互斥锁的线程默认拥有锁标记, 效率较快但写法相对繁琐

线程安全的集合类

悲观锁: 悲观的认为集合一定会出现线程安全问题,所以直接加锁

乐观锁: 乐观的认为集合一定不会出现线程安全问题,如果安全问题发生,再利用算法解决问题(无锁机制)

JDK5.0,发布了一批无锁机制的线程安全的集合类

都来自于java.util.concurrent包

  1. ConcurrentHashMap: CAS算法

    compare and swap: 比较并交换

    原有值,预期值,结果值: 当原有值与预期值相等时才会将结果值放入内存

    int i=1;

    i++;

    原有值: 1 预期值: 1 结果值:2

  2. CopyOnWriteArrayList:

    • 当集合进行写(增删改)操作时,会先复制出一个副本,在副本中进行写操作,如果过程中出现线程安全问题,则舍弃当前副本,重新复制新的副本重复操作,直至副本中无异常,再将集合引用地址转换向副本地址,一次确保原集合中一定不会发生安全问题
    • 特点: 舍弃写的效率提高读的效率,适用于读操作远多于写操作时

  3. CopyOnWriteArraySet:

    • 原理与CopyOnWriteArrayList一致, 在写时会对元素进行去重

今日掌握

  1. 进程和线程的特点
  2. 线程的两种创建方式
  3. 线程的基础状态及触发时机
  4. sleep和join的区别
  5. 线程池的作用的使用
  6. Runnable和Callable的区别
  7. 什么是线程安全问题?
  8. 如何解决线程安全问题
  9. 同步方法和同步代码块的区别
  10. 线程安全的集合类及原理
田北
关注
  • 54
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
吴名氏的博客
06-09 9万+
单核 CPU 支持 Java 多线程吗？我们来一起看看吧
java线程和进程的区别_Java中的线程和进程比较
weixin_33406440的博客
02-17 2442
1.进程和线程的区别通俗一点说，进程就是程序的一次执行，而线程可以理解为进程中的执行的一段程序片段。用一点文词说就是，每个进程都有独立的代码和数据空间(进程上下文);而线程可以看成是轻量级的进程。一般来讲(不使用特殊技术)，同一进程所产生的线程共享同一块内存空间。同一进程中的两段代码是不可能同时执行的，除非引入线程。线程是属于进程的，当进程退出时该进程所产生的线程都会被强制退出并清除。线程占用的资...
python多线程比单线程效率低_多线程比单线程快，是真的吗？
weixin_39800971的博客
02-20 1771
pyrhon视频教程栏目介绍多线程是否真的比单线程快。事实上，Python 多线程另一个很重要的话题叫，GIL(Global Interpreter Lock，即全局解释器锁)。多线程不一定比单线程快在Python中，可以通过多进程、多线程和多协程来实现多任务。难道多线程就一定比单线程快？下面我用一段代码证明我自己得观点。'''@Author： Runsen@微信公众号： Python之王@博客：...
多线程你了解多少？看完你就全明白了！
weixin_38007185的博客
08-14 3204
什么是程序、进程、线程？ 什么是程序？ 程序是指令和数据的有序集合，其本身没有任何的运行含义，是一个静态的概念。就像我们写的代码就是程序。 什么是进程（Process）？ 进程是操作系统结构的基础，是一次程序的执行，资源分配的基本单位。它是一个动态的概念。我们可以这样理解，一个正在操作系统中运行的exe程序可以理解为一个进程，进程是收操作系统管理的基本运行单元。就像我现在运行的谷歌浏览器、印象笔记他们就是一个进程。 windows中的进程图： linux中的进程图： 什么是线程（Thr
多进程和多线程的区别是什么？多进程和多线程的优缺点分析
桐原因的博客
04-19 1万+
多进程和多线程的主要区别是：线程是进程的子集（部分），一个进程可能由多个线程组成。多进程的数据是分开的、共享复杂，需要用IPC；但同步简单。多线程共享进程数据，共享简单；但同步复杂。 　　多进程，Windows 应用程序中消息有两种送出途径；直接和排队。Windows或某些运行的应用程序可直接发布消息给窗口过程，或者，消息可送到消息列象连续不断轮询消息队列的OS中当前执行的每个进程都 ...
进程和线程的区别（操作系统级别解析）
热门推荐
潘建南的博客
12-03 1万+
关于进程和线程，大家总是说的一句话是“进程是操作系统分配资源的最小单元，线程是操作系统调度的最小单元”。这句话理论上没问题，我们来看看什么是所谓的“资源”呢。   什么是计算机资源 经典的冯诺依曼结构把计算机系统抽象成 CPU + 存储器 + IO，那么计算机资源无非就两种： 1. 计算资源 2. 存储资源 CPU是计算单元，单纯从CPU的角度来说它是一个黑盒，它只对输入的指令和数据进行...
进程和线程有什么区别？
csdssdn的博客
07-02 3488
进程是正在运行的程序实例线程是进程中执行执行任务的基本单位也就是说一个运行的程序至少包含一个进程，一个进程至少包含一个线程，线程不能独立于进程存在从计算机角度来说进程（Process）是操作系统分配资源得基本单位，一个进程拥有的资源有自己的堆、栈、虚存空间（页表）、文件描述符等信息 ，从编程的角度来看待进程，可以将其看做是一个类或者一个PCB（Process Control Block）进程控制块的结构体。此结构体大致包含以下内容：1. 进程编号PID 进程的身份标识2. 进程的状态3. 进程状态4. 就
进程和线程：进程的开销比线程大在了哪里？
weixin_41803650的博客
02-04 3062
不知你在面试中是否遇到过这样的问题，题目很短，看似简单，但在回答时又感觉有点吃力？比如下面这两个问题： 进程内部都有哪些数据？ 为什么创建进程的成本很高？ 这样的问题确实不好回答，除非你真正理解了进程和线程的原理，否则很容易掉入面试大坑。本讲，我将带你一起探究问题背后的原理，围绕面试题展开理论与实践知识的学习。通过本讲的学习，希望你可以真正理解进程和线程原理，从容应对面试。 进程和线程 进程（Process），顾名思义就是正在执行的应用程序，是软件的执行副本。而线程是轻量级的进程。 进程是分配资源
【干货】python多进程和多线程谁更快
未名编程
08-08 1065
python多进程和多线程谁更快 python3.6 threading和multiprocessing 自从用多进程和多线程进行编程,一致没搞懂到底谁更快。网上很多都说python多进程更快，因为GIL(全局解释器锁)。但是我在写代码的时候，测试时间却是多线程更快，所以这到底是怎么回事？最近再做分词工作，原来的代码速度太慢，想提速，所以来探求一下有效方法(文末有代码和效果图) 这里先来一张程序的结果图，说明线程和进程谁更快 一些定义 并行是指两个或者多个事件在同一时刻发生。并发是指两个或多个
python多进程和多线程谁更快
我是guyue，guyue就是我O(∩_∩)O
06-16 3243
Python IO密集型任务、计算密集型任务，以及多线程、多进程 - tsw123 - 博客园 https://www.cnblogs.com/tsw123/p/9504460.html Python IO密集型任务、计算密集型任务，以及多线程、多进程选择 对于IO密集型任务： 单进程单线程直接执行用时：10.0333秒 多线程执行用时：4.0156秒 多进程执行用时：...
Linux线程（进程）数限制分析
01-09
1.问题来源 　公司线上环境出现MQ不能接受消息的异常，运维和开发人员临时切换另一台服务器的MQ后恢复。同时运维人员反馈在出现... 　task_struct是内核对进程的管理单位，通过slub(slab的升级版，如果你对slub不了解
深入探讨linux下进程的最大线程数、进程最大数、进程打开的文件数
09-05
本篇文章是对linux下进程的最大线程数、进程最大数、进程打开的文件数进行了详细的分析介绍，需要的朋友参考下
Ruby 多线程的潜力和弱点分析
01-20
Web 应用大多是 IO 密集型的，利用 Ruby 多进程+多线程模型将能大幅提升系统吞吐量。其原因在于：当Ruby 某个线程处于 IO Block 状态时，其它的线程还可以继续执行。但由于存在 Ruby GIL (Global Interpreter Lock)...
Python多进程与服务器并发原理及用法实例分析
01-20
无论是并行还是并发，在用户看来都是’同时’运行的，不管是进程还是线程，都只是一个任务而已，真是干活的是cpu，cpu来做这些任务，而一个cpu同一时刻只能执行一个任务 一 并发：是伪并行，即看起来是同时运行。...
linux系统编程之线程.zip
05-05
2. 从内核里看进程和线程是一样的，都有各自不同的PCB，但是PCB中指向内存资源的三级页表是相同的 3. 进程可以蜕变成线程 4. 线程可看做寄存器和栈的集合 5. 在linux下，线程最是小的执行单位；进程是最小的分配资源...
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 335
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
【Java02】Java中数组的定义与初始化
饮冰室
06-10 606
推荐第一种方式。这种方式容易让人理解，数据类型是type[]，对象名称是arrayName。第二种方式有些老旧了。由于数组是一种引用变量（也就是一个指针），所以定义的时候还没有指向任何有效的内存空间，因此在定义数组的时候不能指定数组的长度，也不能直接使用。必须进行初始化。可以使用var让系统自动推断变量类型，既可以用于静态初始化，也可以用于动态初始化。
盲盒App开发时有哪些技术框架可以借鉴
最新发布
bytekj的博客
06-14 557
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 419
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
linux环境，程序运行中如何抓个dmp，看下线程的状态
06-13
core dump是进程崩溃或异常退出时生成的一份内存映像，包含程序运行时的内存和寄存器状态等信息，可以用于后续的调试分析。可以使用如下命令抓取程序的core dump： ``` gcore ``` 其中，`<pid>`是程序的进程ID。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值