2021.6.28 多线程【狂神系列】

最新推荐文章于 2023-07-19 20:23:29 发布
最新推荐文章于 2023-07-19 20:23:29 发布
阅读量386 收藏
点赞数
分类专栏： java 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dearand/article/details/121621984
版权

2021.6.28 多线程

什么是多线程：

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运算单位，而多线程就是指从软件或者硬件上实现多个线程并发执行的技术，具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。

简单来说：线程是程序中一个单一的顺序控制流程；而多线程就是在单个程序中同时运行多个线程来完成不同的工作。

多线程是为了同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。多个线程是同一时间需要完成多项任务的时候实现的。

优点：

1,多线程技术可以加快程序的运行速度，使程序的响应速度更快，因为用户界面可以在进行其他工作的同时一直处于活动状态。
2,可以把占据长时间的程序中的任务放到后台去处理，同时执行其他操作，提高效率
3，当前没有进行处理的任务时可以将处理器时间让其他任务
4，可以让同一个程序的不同部分并发执行，释放一些珍贵的资源如内存占用等等。
5，可以随时停止任务
6，可以分别设置各个任务的优先级以优化性能

缺点：

1，因为多线程需要开辟内存，而且多线程切换需要时间因此会很消耗系统内存
2，线程的终止会对程序产生影响
3，由于多个线程之间存在共享数据，因此容易出现线程死锁的情况
4，对线程进行管理要求额外的cpu开销。线程的使用会给系统带来上下文切换的额外负担

1，多线程有什么用？

1）发挥多核cpu的优势

随着工业的进步，现在的笔记本，台式机乃至商用的应用服务器至少也都是双核的，4核，8核甚至16核，如果是单线程的程序，那么在双核cpu上就浪费了50%，单核cpu上，所谓的多线程那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换的比较快，看着像多个线程同时运行罢了。多核cpu上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程可以真正发挥出多先线程的优势来，达到充分利用cpu的目的。

2）防止阻塞

从程序运行效率的角度来说，单核不但不会发挥出多线程的优势，反而会因为在单核cpu上运行多线程导致线程上下文的切换，而降低程序的整体的效率.但是单核cpu我们还是要应用多线程，就是为了防止阻塞。如果单核cpu使用单线程，那么只要这个线程阻塞了，比方说远程读取某个数据吧，对端迟迟未返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其他任务的执行。

3）便于建模

这就是另外一个没有这么明显的优点了。假设有一个大的任务A，单线程编程，那么就要考虑很多，建立整个程序模型比较麻烦，但是如果这个大的任务A分解程几个小任务，任务B，任务C，任务D，分别建立程序模型，并通过多线程分别运行这几个任务，那就简单很多了。

2，线程和进程的区别

进程和线程的主要差别在于他们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃以后，在保护模式下不会对其他进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但是线程之间没有的单独的地址空间，一个线程死掉就等于整个进程的死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换的时候，耗费资源比较大，效率要差一些。但是对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程.

3,java实现线程的方式

  1. 继承Thread 类实现多线程

2）实现Runnable 接口实现多线程

3）使用 ExecutorService ，Callable ，Future 实现有返回结果的多线程。

4，启动线程的方法 start（）和 run（）有什么区别

只有调用了start() 方法，才会表现出多线程的特征，不同线程的 run（）方法里面的代码交替执行。如果只是调用run() 方法，那么代码还是同步执行的，必须等待一个线程的 run（）方法里的代码全部执行完毕之后，另外一个线程才可以执行其 run（）方法里面的代码。

5，如何终止一个线程，以及如何优雅的终止线程

stop,不推荐

6，线程的生命周期有哪几种状态，以及他们之间的流转

  • new：创建线程，没开始启动
  • runnable：表示线程触发start（）方式调用，线程正式启动，线程处于运行中状态
  • blocked：表示线程阻塞，等待获取锁（资源锁），如碰到synchronized，lock等关键字等占用临界区的情况，一旦获取到锁就进行runnable 状态继续运行。
  • waiting：表示线程处于无限制等待状态，等待一个特殊的事件来重新唤醒，如wait（）方法进行等待的线程等待一个 notify（） 或者 notifyAll（）方法，通过join（）方法进行等待的线程等待目标线程运行结束而唤醒，一旦通过相关事件唤醒线程，线程就进入到了runnable 状态继续运行。
    • Timed_waiting：表示线程进入到了一个有时限的等待，如sleep（3000），等待3 秒后线程重新进入到 runnable 状态继续执行。
    • terminated：表示线程执行完毕后，进行终止状态。需要注意的是，一旦线程通过start方法启动后就再也不能回到初始 new 状态，线程终止后也再不能回到 runnable 状态。

7，线程中的wait（）和 sleep() 方法有什么区别

sleep 方法 和 wait() 方法都可以用来放弃cpu 一定的时间，不用点在于 如果线程持有某个对象的监视器，sleep 方法不会放弃这个对象的监视器，wait 方法会放弃这个对象的监视器。

8，多线程同步有哪些方法

  • synchronized 关键字
  • lock 锁实现
  • 分布式锁等

9，死锁

死锁就是两个线程互相等待对方释放对象锁

10，多线程之间如何通信

wait
notify

11,线程怎样拿到返回结果

实现callable接口

12，volatile 关键字

主要作用：
1，多线程主要围绕可见性和原子性两个特性而展开，使用volatile 关键字修饰的变量，保证了其再多线程之间的可见性，即每次读取到 volatile 变量，一定是最新的数据
2，代码底层执行：java代码-》字节码-》根据字节码对应的c/c++ 代码——》c/c++代码被编译程汇编语言-》和硬件电路交互，现实中，为了获取更好性能的jvm可能会对指令进行重排序，多线程下可能会出现一些意想不到的结果。使用volatile 则会对禁止语义重排序，当然这也一定程度上降低了代码执行效率从实践角度而言，volatile 的一个重要作用就是和CAS结合，保证原子性，详细的可以参见 
java.util.concurrent.atomitc 包下的类，如AtomicInteger

13，新建 t1，t2，t3三个线程，如何保证他们的执行顺序

使用join方法

14，线程池

不使用线程池
每个线程都要通过 new Thread（xxRunnable）.start（）的方式创建并运行一个线程
当线程少的话这不会是问题，但是真实环境可能会开启多个线程让系统和程序达到最佳效率，当线程数达到一定数量就会耗尽系统的cpu和内存资源，也会造成gc频繁收集和停顿，因为每次创建和销毁一个线程都是需要消耗系统资源的，如果为每个任务都创建线程这无疑是一个很大的性能瓶颈。所以，线程池中的线程复用极大节省了系统资源，当线程一段时间不再有任务处理时它也会自动销毁，而不会常驻内存。

1.线程

1.1线程的一些方法

1）yield

让出当前cpu资源，等待调度重新去竞争

2）join

1.2静态代理模式

​ 静态代理模式就是多线程的底部实现原理

关于多线程

  1. 真实角色和代理角色都实现了一个公共的接口
  2. 代理角色可以是做真实角色做不了的事情

示例

package com.zp;

/**
 * @author zhangpeng
 * @version 1.0
 * @description 静态代理模式 ：多线程的底层原理
 * @date 2021/11/14 22:48
 */
public class ThreadDemo4 {
    public static void main(String[] args) {
        new WendingCompany(new Me()).HappyMary();
        /**
         * 关于 静态代理和多线程的故事
         * 1、静态代理模式是多线程的基础
         * 2、无论是使用 继承Thread还是实现Runnable接口，实际上他俩使用的都是实现了Runnable接口，
         *      所以Runnable接口的run方法实际上就是可以看作一个公共方法，
         * 3、Thread和Runnable看作代理对象，继承或者实现它的那个类看作是真实对象，start就是启动方法
         */
        new Thread(()-> System.out.println("测试lambda表达式方式使用多线程")).start();
    }


}
//需要共同实现的接口
interface Mary {
    //方法
    void HappyMary();
}

//真实角色
class Me implements Mary{

    //实现方法
    @Override
    public void HappyMary() {
        System.out.println("要结婚了");
    }
}

//代理角色
class WendingCompany implements Mary {

    private Mary target;

    public WendingCompany(Mary target) {
        this.target = target;
    }

    @Override
    public void HappyMary() {
        before();
        this.target.HappyMary();
        after();
    }

    //结婚之后做的事情
    private void after() {
        System.out.println("收拾");
    }

    //结婚之前做的事情
    private void before() {
        System.out.println("准备");
    }
}

1.3lambda

​ lambda是jdk1.8的新特性，在于简化代码

package com.zp;

/**
 * @author zhangpeng
 * @version 1.0
 * @description 测试lambda 与 函数式接口 和 匿名内部类
 * @date 2021/11/15 23:14
 */
public class TreadDemo4 {
    //简化1：通过静态内部类、
    static class Like2 implements ILike {

        @Override
        public void test() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        //输出：接口new 实现类
        ILike like = new Like();
        like.test();

        Like2 like2 = new Like2();
        like2.test();

        //简化2：局部内部类
        class Like3 implements ILike {

            @Override
            public void test() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.test();

        //简化3：使用匿名内部类
        like = new Like() {
            @Override
            public void test() {
                System.out.println("I like lambda4");
            }
        };
        like.test();

        //简化4：使用lambda
        like = () ->{
            System.out.println("I like lambda5");
        };
        like.test();

        // 关于 lambda：
        //1.由参数，lambda运算符，函数体组成
        //2.参数：当参数 只有一个的时候可以去掉(),并且可以去掉参数的数据类型，java会自动推到
        //3.函数体：当函数体只有一句话的时候可以去掉{}，
        //4.lambda的基础就是：匿名内部类和函数式接口
    };


    }



//1.定义函数式接口：就是只有一个方法的接口
interface ILike {
    void test();
}

//2.接口的实现类
class Like implements ILike {

    @Override
    public void test() {
        System.out.println("I like lambda");
    }
}

1.4停止线程

​ 关于停止线程：使用外部标志位来停止线程

package com.zp;

/**
 * @author zhangpeng
 * @version 1.0
 * @description 测试线程停止
 * @date 2021/11/16 22:21
 */
public class ThreadDemo5 implements Runnable{
    /**
     * 1、让线程自己停下来
     * 2、建议使用标志位来停止线程
     * 3、不推荐使用已经过时的方法：stop，destroy
     */

    //1、标识位
    boolean flag = true;
    @Override
    public void run() {
        int i= 0;
        while (flag) {
            System.out.println("Thread-->"+i++);
        }
    }

    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        ThreadDemo5 thread = new ThreadDemo5();
        new Thread(thread).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main:->"+i);
            if (i==900) {
                thread.stop();
                System.out.println("线程该停止了");
            }
        }
    }


}

1.5 sleep

​ sleep方法：一般都是用来做一些即时的方法

​ sleep方法也不会释放锁

package com.zp;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.Date;

/**
 * @author zhangpeng
 * @version 1.0
 * @description 测试sleep方法
 * @date 2021/11/16 22:43
 */
public class TreadDemo6 implements Runnable{
    @Override
    public void run() {

    }

    public static void main(String[] args) throws InterruptedException {
        //1.模拟倒计时
        timeDown();
        //2.模拟系统时计
        Date date = new Date(System.currentTimeMillis());
        while (true) {
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("hh:MM:ss").format(date));
            date = new Date(System.currentTimeMillis());
        }

    }

    //1.模拟倒计时
    static void timeDown() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0) {
                break;
            }
        }
    }
}

1.6yield

礼让

1.7线程的状态

​ 线程大致分为5种状态：new，就绪，运行，阻塞，结束

  1. new

    尚未启动的线程处于此状态

  2. runnable

    在java虚拟机中执行的线程处于此状态

  3. blocked

    被阻塞等待监视器锁定的线程处于此状态

  4. waiting

    正在等待另一个线程执行特定动作的线程处于此状态

  5. timed_waiting

    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

  6. terminated

    已退出的线程处于此状态

状态图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dD1Tnfe8-1638285447112)(C:\Users\zp\Desktop\java\java多线程\多线程图库\线程的状态.jpg)]

1.8synchronized

​ 两种用法：同步方法和同步代码块=

  1. 同步方法：是修饰方法的，锁的是this，也就是类的实例
  2. 同步代码块：锁的是共享变量

同步代码块-实例

未加锁之前

package com.zp;

import java.util.ArrayList;

public class ThreadSynchronized3 {
    public static void main(String[] args) throws InterruptedException {
        ArrayList<String> arrayList = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                //synchronized : 这里是同步代码块 锁的是共享变量（也就是变化的量)
      arrayList.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(arrayList.size());
    }
}
//输出：不等于

加锁之后

package com.zp;

import java.util.ArrayList;

public class ThreadSynchronized3 {
    public static void main(String[] args) throws InterruptedException {
        ArrayList<String> arrayList = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                //synchronized : 这里是同步代码块 锁的是共享变量（也就是变化的量）
                synchronized (arrayList) {
                    arrayList.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(arrayList.size());
    }
}
//输出：10000

同步方法-实例

未加锁之前

package com.zp;


public class ThreadSynchronized2 {
    public static void main(String[] args) {
        Account account = new Account(100, "基金");
        bank one = new bank(account, 50, "买白酒");
        bank two = new bank(account, 100, "买军工");
        one.start();
        two.start();
    }
}

//账户
class Account{
    int money;//余额
    String name;
    public Account(int money,String name) {
        this.money = money;
        this.name = name;
    }
}

//银行
class bank extends Thread{
    Account account;//账户
    int drawMoney;//取钱
    int nowMoney;//现钱

    public bank(Account account, int drawMoney, String name) {
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;

    }

    @Override
    public void run() {
            //synchronized :这里是同步代码块，锁的共享变量
           synchronized (account) {
               //首先判断有没有钱
               if (account.money-drawMoney<0) {
                   System.out.println(Thread.currentThread().getName()+"需要："+this.drawMoney+ "  钱不够了");
                   return;
               }
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               //账户的钱
               account.money -=drawMoney;
               //现钱
               nowMoney+=drawMoney;
               System.out.println(this.getName()+"的钱:"+nowMoney);
               System.out.println(account.name+"余额为："+account.money);
           }


       }
}
//输出：
/*
买军工的钱:100
基金余额为：-50
买白酒的钱:50
基金余额为：-50
*/

加锁之后

package com.zp;


public class ThreadSynchronized2 {
    public static void main(String[] args) {
        Account account = new Account(100, "基金");
        bank one = new bank(account, 50, "买白酒");
        bank two = new bank(account, 100, "买军工");
        one.start();
        two.start();
    }
}

//账户
class Account{
    int money;//余额
    String name;
    public Account(int money,String name) {
        this.money = money;
        this.name = name;
    }
}

//银行
class bank extends Thread{
    Account account;//账户
    int drawMoney;//取钱
    int nowMoney;//现钱

    public bank(Account account, int drawMoney, String name) {
        super(name);
        this.account = account;
        this.drawMoney = drawMoney;

    }

    @Override
    public void run() {
            //synchronized :这里是同步代码块，锁的共享变量
           synchronized (account) {
               //首先判断有没有钱
               if (account.money-drawMoney<0) {
                   System.out.println(Thread.currentThread().getName()+"需要："+this.drawMoney+ "  钱不够了");
                   return;
               }
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               //账户的钱
               account.money -=drawMoney;
               //现钱
               nowMoney+=drawMoney;
               System.out.println(this.getName()+"的钱:"+nowMoney);
               System.out.println(account.name+"余额为："+account.money);
           }


       }
}
//输出：
/*
买白酒的钱:50
基金余额为：50
买军工需要：100  钱不够了
*/

1.8.1关于synchronized的理解

​ 说实话，认识它很久了，但是一直都是一知半解，今天打算好好理理它

1.9生产者消费者模式-管程法

​ 通过一个缓冲区，生产者生产，消费者消费；来做到一个多线程之间的通信

  1. wait:等待（不同与sleep，wait会释放cpu资源，就是释放锁）
  2. notify/notifyAll，（唤醒/唤醒所有的线程）
package com.zp;

import java.awt.print.Pageable;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

/**
 * @author zhangpeng
 * @version 1.0
 * @description 生产者，消费者模式，管程法
 * @date 2021/11/30 20:35
 */
public class ThreadDemo7 {
    public static void main(String[] args) {
        SynContainer synContainer = new SynContainer();
        new Producter(synContainer).start();
        new ConSumer(synContainer).start();
    }
}

    //生产者
      class Producter extends Thread {
        SynContainer synContainer;

        public Producter(SynContainer synContainer) {
            this.synContainer = synContainer;
        }

        @Override
        public void run() {
            for (int i = 1; i < 100; i++) {
                synContainer.setPhone(new Phone(i));
                System.out.println("生产了："+i+"个Phone");
            }
        }
    }

    //消费者
      class ConSumer extends Thread {
        SynContainer synContainer;

        public ConSumer(SynContainer synContainer) {
            this.synContainer = synContainer;
        }

        @Override
        public void run() {
            for (int i = 1; i < 100; i++) {
                    synContainer.getPhone();
                System.out.println("消费了第："+i+"个手机");
            }
        }
    }

    //产品
      class Phone {
        int num;

        public Phone(int num) {
            this.num = num;
        }
    }

    //缓冲区
      class SynContainer {
        //容器
        List<Phone> list = new ArrayList<>();
        //Phone[] phones = new Phone[10];
        //容器计数器
        int count= 0;

        //生产
        synchronized void setPhone(Phone phone)   {
            //如果容器满了，需要通知消费者消费
           // if (phones.length== count) {
            if (list.size()== 10) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果没有满，需要生产者生产
            //phones[count] = phone;
            list.add(phone);
            count++;
            //通知消费者消费
            this.notifyAll();
        }

        //消费
        synchronized Phone getPhone()   {
            //判断能否消费
            if (count == 0) {
                //等待生产者生产，消费者等待
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //如果可以消费
            count --;
            //Phone phone = phones[count];
            Phone phone = list.get(count);
            //消费完了通知生产
            this.notifyAll();
            return phone;
        }
    }

1.10生产者消费者模式-信号灯法

信号灯法：就是创建一个控制变量，通过改变控制变量的值来实现线程之间的通信

package com.zp;

/**
 * @author zhangpeng
 * @version 1.0
 * @description 生产者，消费者模式，信号法
 * @date 2021/11/30 22:08
 */
public class ThreadDemo8 {
    public static void main(String[] args) {
        Views views = new Views();
        new Dancer(views).start();
        new Player(views).start();
    }
}

//生产者，舞蹈区up
class Dancer extends Thread{
    Views views;

    public Dancer(Views views) {
        this.views = views;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0) {
                this.views.dance("欣小萌的舞蹈");
            } else {
                this.views.dance("开卷");
            }
        }
    }
}

//消费者，我->观众老爷
class Player extends Thread{
    Views views;

    public Player(Views views) {
        this.views = views;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            this.views.play();
        }
    }
}

//产品，视频
class Views {
    //产品，视频
    String view;
    /**
     * 控制变量
     * t：生产者生产
     * f: 消费者消费
     */
    boolean flag = true;

    //生产
    public synchronized void dance(String view) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("打开了："+view);
        this.notifyAll();
        this.view = view;
        this.flag = !this.flag;
    }

    //消费
    public synchronized void play() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("我观看了:"+view);
        this.notifyAll();
        this.flag = !this.flag;
    }

}

1.11线程池

​ 关于线程池：线程池是用来管理线程的，一是减少资源消耗，二是方便管理

线程池的好处

创建线程池的方法

  1. Executors

    工具类，线程池的工厂类，用于创建并返回不同类型的线程池

  2. ExecutorService

    真正的线程池接口，常见子类：ThreadPoolExecutor

常见方法

  1. void executor(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
  2. <T> Future<T> submit(Callable<T> task):执行任务，有返回值，一般用来执行Callable
  3. void shutDown():关闭线程池

实例

package com.zp;

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

/**
 * @author zhangpeng
 * @version 1.0
 * @description 线程池
 * @date 2021/11/30 23:03
 */
public class ThreadDemo9 {
    public static void main(String[] args) {
        //Executors：创建线程池工具类
        //newFixedThreadPool ：参数 int 线程数量
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        //执行方法
        executorService.execute(new ThreadPool());
        executorService.execute(new ThreadPool());
        executorService.execute(new ThreadPool());
        executorService.execute(new ThreadPool());

        //关闭连接
        executorService.shutdown();
    }
}

//实现Runnable接口
class ThreadPool implements Runnable {

    @Override
    public void run() {
        System.out.println("该睡觉了");
    }
}

1.12多线程的总结

​ 这个总结没讲啥，就是创建线程的三个方式；顺带说了一嘴线程的同步。总的来说关于多线程的章节，讲的太简单了；后续学习的话，推荐看java编程的逻辑一书，讲的很通俗很全面，看完可以接着看多线程并发的艺术和java多线程编程核心技术，java并发编程等书

六月的六
关注
专栏目录
多线程
hjh3132778226的博客
04-09 1020
多线程 文章目录多线程一、多线程简介1.多任务2.多线程3.程序.进程.线程4.Process与Thread5.核心概念二、线程实现1.线程创建（三种方法）1.1继承Thread类(重要)案例1.2实现Runnable接口案例龟兔赛跑:1.3实现Callable接口（了解）好处1.4Thread和Runnable对比2.静态代理实现: 结婚案例总结好处3.Lamda表达式函数式接口的定义:练习:练习2:总结:三、线程状态1.线程五大状态:2.线程方法2.1停止线程案例:测试stop2.2线程休眠案例:模拟网
Java多线程（引用--＞狂神学习笔记）2021-09
煮酒客的博客
09-07 306
狂神说多线程笔记整理 笔记总结来自狂神说Java多线程详解 一、线程简介 1. 多任务 现实中太多这样同时做多件事情的例子了，看起来是多个任务都在做，其实本质上我们的大脑在同一时间依旧只做了一件事情。 2. 多线程 原来是一条路，慢慢因为车太多了，道路阻塞，效率极低。为了提高使用的效率，能够充分利用道路，于是加了多个车道。从此，妈妈再也不用担心道路阻塞了。 3. 程序.进程.线程 4. Process与Thread 说起进程,就不得不说下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义
狂神多线程
qq_40826814的博客
04-19 291
学习视频参考链接：https://www.bilibili.com/video/BV1V4411p7EF?p=27 线程简介 线程的实现（重点） 线程状态 线程同步（重点） 线程通信问题 高级主题（重点） 文章目录 1、线程简介 2、线程实现 2.1 继承 Thread 类，重写 run 方法 2.2 继承 Runnable 接口，创建 Tread 对象 2.3 实现 Callable 接口（了解） 2.4 Lamda 表达式 2.5 静态代理模式 3、线程的 5 种状态 .
Java多线程机制（狂神版，附源代码）
LSP522的博客
05-16 612
Java体系的一个重要部分就是多线程。在JAVA程序中，线程的最普遍用途是允许Applet在接受用户输入的同时，在屏幕的另一部分显示动画。使用多线程可以编写出CPU最大利用率的高效程序，因为空闲时间保持最低。这对Java运行的交互式的网络互连环境是至关重要的。 package Thread; import java.awt.*; import java.awt.event.*; import java.applet.*; public class Counter1 extends App
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3449
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
【狂神说笔记——JVM入门】
weixin_46055348的博客
06-25 448
狂神说笔记——JVM入门
狂神说2021-最全课程资料
09-18
《狂神说2021-最全课程资料》是一份综合性的学习资源包，包含了丰富的Java编程知识，旨在帮助学习者系统性地掌握Java语言并提升编程技能。该资源包更新于2021年9月18日，确保了内容的新颖性和实用性。下面我们将深入...
Java多线程进阶之JUC并发编程教程详解（狂神说学习笔记）
super_song的博客
05-01 1177
文章目录环境准备1.JUC 简介2.线程和进程线程和进行并发和并行线程的状态wait/sleep的区别3.Lock 锁（重点）Synchronized 传统的锁Lock锁synchronized 和 lock 锁的区别4.生产者和消费者问题Synchronized 版本JUC 版本5.八个有关锁的问题问题1：两个同步方法，先执行发短信还是打电话？问题2：如果发短信延迟2秒，谁先执行问题3 加上一个没有锁的普通方法，谁先执行问题4：两个对象，一个调用发短信，一个调用打电话，谁先执行问题5：原来的两个同步方法，
JUC并发多线程进阶
早上真起不来的博客
06-09 307
笔记整理来源 B站UP主狂神说Java https://space.bilibili.com/95256449/ JUC并发多线程进阶 1、什么是JUC 源码+官方文档 JUC是 java util concurrent 面试高频问JUC~！ java.util 是Java的一个工具包~ 业务：不会通过普通的线程代码 Thread 来实现 Runnable： 没有返回值、效率相比于Callable 相对较低！ 2、线程和进程 进程：一个程序，QQ.exe Music.exe；数据+代码+pcb 一个进程可
thread.zip--狂神多线程+juc
03-18
B站狂神说Java的多线程基础篇+juc高级篇代码
【狂神说Java】Java多线程详细笔记(全)
Martin-share的博客
01-13 987
【狂神说Java】Java多线程笔记
多线程—狂神说
TiAmo的博客
07-10 235
1.什么是多线程 多任务：同时做多件事，边看电视变吃饭边听歌（但是实际上是分时进行的，大脑的处理速度很快） **多线程：**多条线路同时执行，比如打游戏你可以和你朋友同时开黑。 普通方法调用： 1.调用run()，此时只有主线程一条依次执行路径 2.调用start(),开启多线程，多条执行路径，主线程与子线程并行交替执行。 进程与线程 程序就是数据和指令的有序集合，其本身没有任何运行的含义，是静态的，而进程是动态的的程序。 而进程是执行程序的一次执行，它是动态的概念，进程是资源分配资源的单位 通常一个进
认识多线程（区别；优点；执行顺序；创建线程）
weixin_43660497的博客
05-01 171
1 static final int Count=10; //计算Count次 static final int Number=10_0000_0000; //Number个数字 2 static final int Count=10; //计算Count次 static final i...
多线程讲解狂神说
weixin_44502509的博客
06-16 3777
多线程讲解 学无止境,不学习就会被社会淘汰。笔记总结自狂神说多线程讲解 基本概念 进程 进程就是执行程序的一次执行过程,它是一个动态的概念,式系统资源分配的单位 通常再一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位 线程 线程就是独立的执行路径 在程序运行时,即使没有自己创建线程,后台也会有多个线程,比如主线程,GC线程 main()称之为主线程,为系统的入口,用于执行整个程序 在一个进程中,如果开辟了多个线程,线程的运行是由调度器安排
狂神说多线程笔记
m0_51654746的博客
04-02 1036
进程与线程 进程是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的一次，线程是CPU调度和执行的单位 注：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器，如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。 多线程其实就是让不同的线程去操作同一个对象 线程创建 Thread class 继承Thread类(
狂神说Java学习笔记——多线程
最新发布
weixin_65098078的博客
07-19 1509
狂神说Java学习笔记——多线程
Java多线程详解[狂神说Java]
阿正的梦工坊
03-07 874
记录知识，形成体系
Java并发编程详解：JUC工具包与多线程实战
例如，通过将一个大任务拆分成多个小任务，多个线程可以并发处理，从而缩短整体的执行时间。在Java中，JUC库提供了一系列工具，如ThreadPoolExecutor、Semaphore、CyclicBarrier和CountDownLatch等，帮助开发者有效...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值