多线程相关笔记

最新推荐文章于 2024-08-10 16:13:20 发布
最新推荐文章于 2024-08-10 16:13:20 发布
阅读量53 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46658667/article/details/115271660
版权
本文详细介绍了多线程的概念，包括进程、线程调度、同步与异步、并发与并行。深入讲解了Java中实现多线程的方式，如Thread类、Runnable接口，并对比了两者的优缺点。此外，还探讨了线程的命名、休眠、阻塞、中断、守护线程以及线程安全。最后，介绍了线程池ExecutorService的重要性和四种类型的线程池，以及如何利用lambda表达式进行函数式编程。
摘要由CSDN通过智能技术生成

进程

  • 是指一个内存运行的应用程序，每一个进程都有一个独立的内存空间
  • 一个进程启动后，里面若干的执行路径可划分为若干线程

线程

  • 在进程的基础上进行划分的是它的一个执行路径，共享一个内存空间
  • 线程之间可以自由切换，并发执行
  • 一个进程最少有一个线程

线程调度

  • 分时调度：所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间。
  • 抢占式调度：
    • 优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个（线程随性机）,Java使用的为抱占式调度。
    • CPU使用抢占式调度模式在多个线程间进行着高遇的切换,对于CPU的一个核新而言,某个时刻,只能执行一个线程,而CPUB9在多个线程间切资速度相对我们的觉要快,看上去就是在同一时刻运行,其实,多线是程序井不能提高程序的运行速度,但能够提高程序进行效,让CPU的使用率更高

同步与异步

  • 同步：排队执行，效率低但是安全
  • 异步：同时执行，效率高但不安全

并发与并行

  • 并发：两个或多个事件在同一时间段内发生
  • 并行：两个或多个事件在同一时间刻发生

在Java中实现多线程技术

  • Thread类：提供的用于实现线程的类
public class myThread extends Thread{
    /**
     *run 方法就是线程要执行的任务方法
     */
     public void run(){
         //这里代码就是一条路径
         //这个执行路径的处罚方式，不是调用run方放，而是通过Thread对象的start()来启动任务
         for(int i=0;i<10;i++){
             System.out.ptintln("我爱学习"+i);
         }
     }
}
//重新创建一个类
public class Try{
    public static void main(String[] args){
    //Thread
    myThread m = new myThread();
    m.start();
        for(int i=0;i<10;i++){
             System.out.ptintln("学习爱我"+i);
         }
    }
}
//分配时抢占式分配 两个线程 每次执行结果都可能不一样
  • 实现Runnable接口
  • 优势：
    • 通过创建线程任务再分配的方式来实现，更适合多个线程同时执行相同任务情况
    • 可避免单线程带来的局限
    • 任务与线程时分离的，提高程序健壮性
    • 后续学习的线程池技术，接受该类型任务，不接受Thread类线程
public class myRunnable implements Runnable{
    @Override
    public void run(){
        //线程的任务
        for(int i=0;i<10;i++){
             System.out.ptintln("我爱学习"+i);
         }
    }
}
//这个类写好之后就相当于有了一个给线程执行的任务
//实现该任务还得借助于Thread
public static void main(String[] args){
    //实现Runnaale
    //1.创建一个任务对象
    myRunnable r = new Runnaale();
    //2.创建一个线程，为其分配任务
    myThread m = new myThread(r);
    m.start();
    
    for(int i=0;i<10;i++){
         System.out.ptintln("学习爱我"+i);
    }
}

设置和获取线程名称

System.out.println(Thread.currentThread().getName ());
//Thread.currentThread() 获取当前正在执行的线程对象
//得到的类型是Thread

线程休眠sleep

    for(int i=0;i<10;i++){
         System.out.ptintln(i);
         Thread.sleep(millis:1000);
         //里面能添毫秒/毫秒加纳秒
         //millis:1000 一千毫米==一秒
    }

线程阻塞

  • 所有比较消耗时间的操作

线程的中断

  • 一个线程是一个独立的执行路径，它是否应该结束应有自身决定
  • 通过打入中断标记来进行，线程在特殊情况时会去查看标记并抛出异常
  • 早期有stop这个方法来从外部掐掉线程，弊端是线程后续操作无法执行
public class Try{
    public static void main(String[] args){
        Thread t1 =new Thread( new myRunnable()); 
        t1.start();
        for(int i=0;i<10;i++){
            System.out.ptintln(Thread.currentThread().getName ()+":"+i);
             try{
                 Thread.sleep(millis:1000);
             }catch(InterruptedException e){
                 e.printStackTrace();
             }
        }
        //给线程t1设置中断标记
        t1.interrupt();
    }
}

public class myRunnable implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<10;i++){
             System.out.ptintln(Thread.currentThread().getName ()+":"+i);
             //因为父类没有抛出异常 所以子类无法使用超出父类的操作
             try{
                 Thread.sleep(millis:1000);
             }catch(InterruptedException e){
                 //e.printStackTrace();
                 //1.发现中断标记了 选择让其自杀
                 System.out.ptintln("发现了中断标记让其自杀");
                 return;
                 //2.也可以发现了中断但是不做处理
                 System.out.ptintln("发现了中断标记不做处理");
             }
         }
    }
}

守护线程

  • 线程分为守护线程和用户线程
  • 用户线程：当一个进程不包含任何的存活用户线程时，进行结束
  • 守护线程：当最后一个用户线程结束时，所有守护线程都自动死亡
    Thread t1 =new Thread( new myRunnable()); 
    //设置成守护线程
    t1.setDaemon(true);
    t1.start();

保证线程安全

隐式锁

  • 同步代码块
    • 格式：synchronized(锁对象){} 锁对象必须是同一把锁 {}里是被执行的操作
  • 同步方法
static class Ticket implements Runnable{
    //票数
    private int cpunt = 10;
    public void run(){
        while(true){
            booleanb flag = sale();
            if(!flag){
            break;
            }
        }
     }
}
public synchronized boolean sale(){
    if(count>0){
    //卖票
    System.out.ptintln("准备卖票");
    try{
        Thread.sleep(millis:1000);
    }catch(InterruptedException e){
        e.printStackTrace();
    }
    count--;
    System.out.ptintln(Thread.currentThread().getName ()+"出票成功，余票："+count);
    return true;
    }else{
     //break;
     return false
    }
}

显式锁Lock

static class Ticket implements Runnable{
    //票数
     private int cpunt = 10;
     //显式锁
     Look lock = new Rentrant();
     public void run(){
        while(true){
            lock.lock();
            if(count>0){
            //卖票
            System.out.ptintln("准备卖票");
            try{
                Thread.sleep(millis:1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            count--;
            System.out.ptintln(Thread.currentThread().getName ()+"出票成功，余票："+count);
            }else{
            //break;
            break;
            }
            lock.unLock();
        }
    }

线程的六种状态

  • new 尚未启动的线程处于此状态
  • runnable 在Java虚拟机中执行的线程
  • blocked 被阻塞等待监视器锁定的线程
  • waiting 无限期等待另一个线程执行特定操作的线程
  • timewaiting 正在等待另一个线程执行最多指定等待时间的操作的线程
  • terminated 已退出的线程

Callbale

runnable与callbale

接口定义
//callbale接口

public interface Callable<v>{
    v call() throws Exception;
}

//runnable接口

public interfac runnable{
    
    public abstract void run();
}

callbale使用步骤

1. 编写类实现callbale接口 实现call()方法
    class xxx implements callbale<>{
        public<T> call() throws Exception{
            return T;
        }
    }
    
2. 创建FutureTask对象 并传入第一步编写的callbale类对象
    FutureTask<Integer> future = new FutureTask<>(callable);

3. 通过Thread 启动线程
    new Thread(future).start();

//使用例子
public static void main(String[] args){
    Callbale<Integer> c = new myCallbale();
    FutureTask<Integer> task = new FutureTask<>(c);
    task.isDone();//判断线程是否执行完毕
    task.cancel();//取消线程()里是布尔类型的
    new Thread(task).start();
    Integer j = task.get();
    System.out.ptintln("返回值为："+J);
    forint i=0;i<10;i++){
        try{
            Thread.sleep(millis:100);
        }catch(InterruptedException e){      
            e.printStackTrace();
        }
        System.out.ptintln(i);
        }
}
static class myCallable implements Callable<Integer>{
    public Integer call() throws Exception{
        //Thread.sleep(3000);
        forint i=0;i<10;i++){
            try{
                Thread.sleep(millis:100);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.ptintln(i);
        }
    }
}

runnable与callbale的相同点

  • 都是接口
  • 都可以编写多线程程序
  • 都采用Thread.start()启动线程

线程池 Executors

  • 如果并发执行的线程较多，每个线程执行任务的时间也很短，那么频繁创建线程、销毁线程会大大降低系统的效率
  • 线程池是一个容纳多个线程的容器，池中线程可以反复使用
    好处
  • 降低资源消耗、提高反应速度、提高线程可管理性

java中四种线程池 ExecutorService

  • 缓存线程池
    • 判断池中是否有空闲线程有就使用，没有的话创建线程放入缓存池中再使用
public class Demo1 {
    /**
     *缓存线程池
     *(长度无限制)
     * 任务加入后的执行流程:
     * 1.判断线程池是否存在空闲线程
     * 2．存在则使用
     * 3．不存在,则创建线程并放入线程池，然后使用
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        //指挥线程池执行新的任务
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        });
        try{
            Thread.sleep(1000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}
  • 定长线程池
    • 判断是否有空闲，没有且线程池未满的情况下创建再使用，若池满则等待空闲
public class Demo2 {
    /**
     * 定长线程池.
     * (长度是指定的数值)
     * 任务加入后的执行流程:
     * 1.判断线程池是否存在空闲线程2.存在则使用
     * 3．不存在空闲线程，且线程池未满的情况下,则创建线程并放入线程池，然后使用
     * 4．不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"我爱学习");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {

                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        });
    }
}
  • 单线程线程池
    • 空闲用不空闲等待
public class Demo3 {
    /**
     * 单线程线程池.
     * 执行流程:
     * 1.判断线程池的那个线程是否空闲
     * 2．空闲则使用
     * 3．不空闲，则等待池中的单个线程空闲后使用
     */
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadExecutor();
        //多执行几个线程 看是不是只出来一个线程名称
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        });
    }
}
  • 周期性任务定长线程池
    • 可定时间隔时长周期重复执行
public class Demo4 {
    /**
     * 周期任务定长线程池.
     * 执行流程:
     * 1.判断线程池是否存在空闲线程
     * 2．存在则使用
     * 3．不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池，然后使用
     * 4.不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
     *
     * 周期性任务执行时:
     * 定时执行，当某个时机触发时，自动执行某任务﹒
     */
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
        /**
         * 1.定时执行一次
         * 参数1．定时执行的任务
         * 参数2．时长数字
         * 参数3．时长数字的时间单位，TimeUnit的常量指定

        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"我爱学习");
            }
        },5, TimeUnit.SECONDS);//五秒钟后执行*/
        /**
         * 周期性执行任务
         * 参数1．任务
         * 参数2．延迟时长数字〔第一次执行在什么时间以后)
         * 参数3．周期时长数字〔每隔多久执行一次)
         * 参数4．时长数字的单位
         */
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"学习爱我");
            }
        },5,1,TimeUnit.SECONDS);//五秒钟后执行第一次，再每间隔一秒执行一次
    }
}

lambda表达式

函数式编程思想
面向对象:创建对象调用方法解决问题．

public class Lambda {
    public static void main(String[] args) {
        //冗余的Runnable代码
        /*
        Thread t = new Thread(new Runnable( ){
        @Override
        public void run() {
            System.out.println("我爱学习");
            }
        });
        t.start();*/

        Thread t = new Thread((/*参数*/)->{
            System.out.println("我爱学习");
            //这个大括号里可以写多个内容用;隔开
        });
        t.start();
    }
}

public class Lambda2 {
    public static void main(String[] args) {
        //修改前
        print(new MyMath() {
            @Override
            public int sum(int x, int y) {
                return x+y;
            }
        },100,200);
        //修改后 保留方法参数部分和方法体
        print((int x, int y) ->{
                return x+y;
        },100,200);
    }

    public static void print(MyMath m,int x, int y){
        int num = m.sum(x, y);
        System.out.println(num);
    }
    static interface MyMath{
        int sum(int x,int y);
    }
}
YYYY_ZI
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java 多线程总结笔记
N0tExpecterr0r的博客
09-19 4360
Java多线程总结笔记 实现多线程的方法 查看Thread类的源码，可以发现它实现了Runnable接口，然后在自己的run方法中调用了Runnable的run方法。这里其实就是静态代理这一设计模式，Thread是代理角色，而Runnable则是真实角色。在Thread的start方法中，会为我们开辟新的线程并执行其run方法，而Thread的run方法会调用它内部持有引用的Runnable的ru...
狂神说多线程笔记
weixin_41963554的博客
09-26 3073
狂神说多线程笔记 bilibli视频地址：https://www.bilibili.com/video/BV1V4411p7EF/ 1.基本概念 Process和Thread 程序：指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 进程：是执行程序的一次执行过程，是一个动态的概念。是系统资源分配的单位。 ​ 一个进程可以包含有多个线程（如视频中同时听到声音、看到图像，还可以看弹幕） ​ 一个进程至少有一个线程，否则无存在的意义。 线程：CPU调度和执行的单
狂神说多线程笔记整理
doris的博客
02-16 1万+
狂神说多线程笔记整理
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3265
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java笔记-多线程相关
IT1995的博客
12-27 4909
ava多线程和C++里面的多线程有些地方不一样。 毕竟套了一个java虚拟机。对此记录下。 Java语言内置多线程支持： 一个java程序实际上是一个JVM进程。 JVM用一个主线程来执行main()方法。 在main()方法中又可以启动多个进程。 Java多线程创建MyThread类逻辑： 1.从Thread派生； 2.覆写run...
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 933
文章标题
多线程基础学习笔记
旋风小陀螺
03-12 1478
多线程基础学习笔记
多线程学习笔记
weixin_44653248的博客
03-30 1648
多线程学习笔记 一、简介 1.正在进行的程序叫做进程。 2.线程（Thread）是进程的基本单位，一个进程可以同时存在多个线程，将线程想想成控制单元。 3.start（）中的静态方法 ①yield（） 时间礼让，不需要抛出异常 ②sleep（） 休眠，需要抛出异常 4.继承Thread方式 5.实现Runnable方式 方法实现： public class Test2 implements Ru...
笔记21-多线程
热门推荐
terence的博客
06-29 6万+
1.实现多线程 1.1进程和线程【理解】 进程：是正在运行的程序 ​ 是系统进行资源分配和调用的独立单位 ​ 每一个进程都有它自己的内存空间和系统资源 线程：是进程中的单个顺序控制流，是一条执行路径 ​ 单线程：一个进程如果只有一条执行路径，则称为单线程程序 ​ 多线程：一个进程如果有多条执行路径，则称为多线程程序 1.2实现多线程方式一：继承Thread类【应用】 方法介绍 方法名 说明 void run() 在线程开启后，此方法将被调用执行 void start()
Python笔记-多线程爬虫实例
IT1995的博客
03-13 4874
如下，线程池两个线程： 线程池关键代码： 源码如下： import re, multiprocessing import requests, time class HandleLaGou(object): def __init__(self): self.laGou_session = requests.session() self.hea...
Java多线程自学笔记
01-19
### Java多线程自学笔记知识点总结 #### 一、Java多线程概念 - **多线程定义**：多线程是指程序中可以同时执行多个线程的能力。Java虚拟机支持多线程...希望这份笔记能够帮助读者更好地理解Java多线程的相关知识。
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
马士兵多线程训练营笔记
02-21
马士兵是一位知名的IT教育专家，他的多线程训练营笔记深入浅出地讲解了这一主题，帮助开发者理解并掌握多线程的精髓。 多线程允许一个程序中有多个执行流同时运行，这样可以提高应用程序的效率和响应性。在Java中，...
Java多线程笔记
03-11
Java多线程笔记 Java多线程笔记是 Java 编程语言中关于多线程编程的笔记，涵盖了线程基础知识、线程优先级、线程状态、守护线程、构造线程、线程中断等多方面的内容。 获取简单 main 程序中的线程 在 Java 中，...
C++ - 函数重载
jiaowenjie的专栏
08-06 317
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
Spring事务
c1tenj2的博客
08-07 429
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 228
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
最新发布
m0_75257168的博客
08-10 207
可以同名，但参数列表不能相同（有参无参构造）
C#多线程编程学习笔记
"C#多线程应用程序的学习笔记，包含了多个示例代码，旨在解释和演示如何在C#中创建和管理多线程应用程序。" 在C#编程中，多线程是一个关键概念，特别是在开发高性能、高并发的应用程序时。线程允许程序同时执行多个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值