Java---线程详解（并发并行，Thread类，Runnable接口，同步机制，线程死锁......）

最新推荐文章于 2024-06-03 10:28:24 发布
最新推荐文章于 2024-06-03 10:28:24 发布
阅读量831 收藏 8
点赞数 2
分类专栏： Java 文章标签： jvm java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61768389/article/details/128092986
版权

目录

一、概念

1、进程

2、线程

（1）单线程

（2）多线程

（3）并发

（4）并行

二、线程基本使用

1、创建线程的两种方式

 （1）继承Thread类

（2）实现Runnable接口

（3）继承Thread和实现Runnable接口的区别

2、多线程执行

售票系统------>

3、线程常用方法

（1）第一组 

（2）第二组 

（3）用户线程和守护线程

三、线程终止

四、线程的生命周期

五、线程同步机制

1、同步概念

2、同步实现synchronized

（1）同步代码块

（2）方法声明

售票系统修正

3、互斥锁

 4、线程死锁

 5、释放锁

（1）以下操作会释放锁

（2）以下操作不会释放锁

一、概念

1、进程

进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。

进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。

2、线程

线程由进程创建的，是进程的一个实体

一个进程可以拥有多个线程

（1）单线程

同一个时刻，只允许执行一个线程

（2）多线程

同一个时刻，可以执行多个线程

（3）并发

同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。

（4）并行

同一个时刻，多个任务同时执行。多核cpu可以实现并行。

二、线程基本使用

1、创建线程的两种方式

  • 继承Thread类，重写run方法
  • 实现Runnable接口，重写run方法
     

 

 （1）继承Thread类

案例1：请编写程序，开启一个线程，该线程每隔1秒。在控制台输出“瞄瞄,我是小猫咪"，

对上题改进：当输出80次瞄瞄，我是小猫咪，结束该线程。

想要看到线程，可以使用JConsole监控线程执行情况。 

注意看注释哦！------>

关于其中用来开启线程的start方法：何不直接用run方法？

注意：run方法只是一个普通的方法，它不会启动一个新的线程，只是方法被调用而已，要把这个run方法执行完毕才能往下执行，并非多线程；需要start开启一个线程。

public class Thread01 {
    public static void main(String[] args){
        // 创建一个Cat对象，可以当做线程使用
        Cat cat = new Cat();
        cat.start(); // 启动线程
        // 当main线程启动一个子线程后，主线程不会阻塞，会继续执行
        // 这时主线程和子线程交替执行
        System.out.print("主线程继续执行"+Thread.currentThread().getName()+"\n");
        for(int i = 0; i < 10 ; i++){
            System.out.print("主线程 i = "+i+"\n");
            // 让主线程休眠
            try{
                Thread.sleep(1000);
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

// 1、Thread类中的run方法是它实现了Runnable接口中的run
// 2、当一个类继承了Thread类，该类就可以当作线程使用
// 3、我们会重写run方法，写上自己的业务代码
class Cat extends Thread{
    public void run(){
        int count = 0;
        while(count != 80){
            count ++;
            // 该线程每隔1秒。在控制台输出"瞄瞄,我是小猫咪"，
            System.out.print("瞄瞄,我是小猫咪"+count+"\n");
            // 让该线程休眠一秒
            try{
                sleep(1000); // 1000ms
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

 JConsole------>

先开始运行程序，然后在控制台中输入JConsole，连接当前进程，之后可在线程中查看相关情况。

（2）实现Runnable接口

案例2：请编写程序，该程序可以每隔1秒。在控制台输出“hi!”,当输出10次后，自动退出。请使用实现Runnable接口的方式实现。

public class Thread02 {
    public static void main(String[] args){
        Dog dog = new Dog();
        Thread thread = new Thread(dog); // Dog类实现了Runnable接口
        thread.start();
    }
}

class Dog implements Runnable{
    public void run(){
        int count = 0;
        while(count != 10){
            count ++;
            System.out.print("hi"+"\n");
            try{
                Thread.sleep(1000); // 1000ms
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

（3）继承Thread和实现Runnable接口的区别

  • 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口      start()->start0()
  • 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

2、多线程执行

案例3：请编写一个程序，创建两个线程，一个线程每隔1秒输出“hello,world!”，输出10次，退出，一个线程每隔1秒输出“hi!”，输出5次退出。

public class Thread03 {
    public static void main(String[] args){
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
    }
}

class T1 implements Runnable{
    public void run(){
        int count = 0;
        while(count != 10){
            count++;
            System.out.println("Hello,world!"+count);
            try{
                Thread.sleep(1000);
            }
            catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

class T2 implements Runnable{
    public void run(){
        int count = 0;
        while(count != 5){
            count++;
            System.out.println("hi!"+count);
            try{
                Thread.sleep(1000);
            }
            catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

售票系统------>

模拟编程三个售票系统同时售票共100张

public class SellTicket {
    public static void main(String[] args){
        SellTicketUse use1 = new SellTicketUse();
        SellTicketUse use2 = new SellTicketUse();
        SellTicketUse use3 = new SellTicketUse();
        use1.start();
        use2.start();
        use3.start();
    }
}

class SellTicketUse extends Thread{
    private static int num = 100;
    public void run(){
        while(true){
            if(num <= 0) {
                System.out.println("票已售完！");
                break;
            }
            try{
                sleep(50); // 模拟售票所需时间
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
            num--;
            System.out.println("窗口"+currentThread().getName()+"售出一张票，剩余票数"+num+"张");
        }
    }
}

 

出现负票数，以上代码得到的结果引出了多线程执行在实际事件中引发的问题：多个线程同时运行会致使共享的数据出现被穿插操作的现象，即上一个线程的买票操作还没有执行时，下一个线程就开始判断共享数据的大小。 

此问题稍后会有解决办法。

3、线程常用方法

（1）第一组 

注意事项------>

  • start 底层会创建新的线程,调用run,run 就是一个简单的方法调用，不会启动新线程
  • 线程优先级的范围
  • interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程。
  • sleep：线程的静态方法，使当前线程休眠
  • 中断不是终止，InterruptedException是捕获到一个中断异常

（2）第二组 

yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定,所以也不一定礼让成功（根据资源是否紧张决定，资源紧张时更容易成功）

join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

 

案例：创建一个子线程，每隔1s输出hello，输出20次，主线程每隔1秒，输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。

public class ThreadMethod02 {
    public static void main(String[] args){
        TUse t2 = new TUse();
        t2.start();

        for(int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
            if(i == 5) {
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕
                Thread.yield();//礼让，不一定成功..
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }

        }
    }
}

class TUse extends Thread {
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

（3）用户线程和守护线程

用户线程：也叫工作线程，当线程的任务执行完或通知方式结束

守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束，常见的守护线程，垃圾回收机制

如何将一个线程设置成守护线程------>

public class ThreadMethod03 {
    public static void main(String[] args){
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当main线程结束后，子线程自动结束,
        //只需将子线程设为守护线程即可
        myDaemonThread.setDaemon(true); // 设置方法
        myDaemonThread.start();

        for( int i = 1; i <= 10; i++) {//main线程
            System.out.println("嘿嘿嘿");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class MyDaemonThread extends Thread {
    public void run() {
        while (true){//无限循环
            try {
                Thread.sleep(1000);//休眠1000毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("哈哈哈");
        }
    }
}

三、线程终止

  • 当线程完成任务后，会自动退出。
  • 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式。
     

需求：启动一个线程t，要求在main线程中去停止线程t，请编程实现。（通知方式）

public class ThreadExit {
    public static void main(String[] args){
        T t = new T();
        t.start();
        // 50s后终止该线程
        try {
            Thread.sleep(2000);
        }
        catch (InterruptedException e){
            e.printStackTrace();
        }
        t.change(false);
    }
}

class T extends Thread{
    private boolean flag = true;
    private int count = 0;
    public void run(){
        while(flag){
            count ++;
            System.out.print("hi"+count+"\n");
            try{
                Thread.sleep(1000); // 1000ms
            }
            catch (InterruptedException e){
                e.printStackTrace();
            }
            if(count == 10){
                break;
            }
        }
    }
    public void change(boolean flag){
        this.flag = flag;
    }
}

四、线程的生命周期

官方文档说法------>6个状态

关于一些教科书上7个状态的说法------>Runnable可运行状态分成了准备状态和正在运行的状态 

 

 可用代码观察到其中一些状态------>

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Thread t3 = new Thread(new T3());//创建子线程
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            if(i == 5) {//说明主线程输出了5次 hi
                t3.start();//启动子线程 输出 hello...
                t3.join();//立即将t3子线程，插入到main线程，让t3先执行
            }
            Thread.sleep(1000);//输出一次 hi, 让main线程也休眠1s
        }
    }
}

class T3 implements Runnable {
    private int count = 0;
    public void run() {
        while (true) {
            System.out.println("hello " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

五、线程同步机制

1、同步概念

在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。

也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

2、同步实现synchronized

（1）同步代码块

synchronized(对象){ // 得到对象的锁，才能操作同步代码
 // 需要被同步的代码;
}

（2）方法声明

synchronized还可以放在方法声明中，表示整个方法为同步方法

public synchronized void m (String name){
 //需要被同步的代码
}

售票系统修正

public class SellTicket {
    public static void main(String[] args) {
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程-窗口
        new Thread(sellTicket03).start();//第2个线程-窗口
        new Thread(sellTicket03).start();//第3个线程-窗口

    }
}


//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum
    private boolean loop = true;//控制run方法变量
    Object object = new Object();
    //同步方法（静态的）的锁为当前类本身
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
    public static  void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }
    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 此时锁在this对象
    //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
    public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法

        synchronized (/*this*/ object) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }

    @Override
    public void run() {
        while (loop) {

            sell();//sell方法是一共同步方法
        }
    }
}

//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享 ticketNum

//    public void m1() {
//        synchronized (this) {
//            System.out.println("hello");
//        }
//    }

    public void run() {


        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));

        }
    }
}


//实现接口方式
class SellTicket02 implements Runnable {
    private int ticketNum = 100;//让多个线程共享 ticketNum

    public void run() {
        while (true) {

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒, 模拟
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2

        }
    }
}

3、互斥锁

  • Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
  • 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
  • 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
  • 同步的局限性：导致程序的执行效率要降低。
  • 同步方法（非静态的）的锁可以是this（当前对象），也可以是其他对象（要求是同一个对象）
  • 同步方法（静态的）的锁为当前类本身。（静态方法无对象）
     

实现步骤：

  • 需要先分析上锁的代码
  • 选择同步代码块或同步方法
  • 要求多个线程的锁对象为同一个（好好理解一下），如果是不同的对象，那么意味着它们的锁也是不同的锁，那么它们根本没有争夺锁进入运行状态这一说法了（锁了个寂寞对吧）

 4、线程死锁

 多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生。

模拟线程死锁------>

public class DeadLock {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}


//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {//构造器
        this.flag = flag;
    }

    @Override
    public void run() {

        //下面业务逻辑的分析
        //1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        //2. 如果线程A 得不到 o2 对象锁（可能有另一个线程刚好拿了o2锁），就会Blocked
        //3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
        //4. 如果线程B 得不到 o1 对象锁（可能有另一个线程刚好拿了o1锁），就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入1");
                synchronized (o2) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入2");
                }

            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入3");
                synchronized (o1) { // 这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入4");
                }
            }
        }
    }
}

 5、释放锁

（1）以下操作会释放锁

  • 当前线程的同步方法、同步代码块执行结束。          案例：上厕所，完事出来
  • 当前线程在同步代码块、同步方法中遇到break、return。           案例：没有正常的完事，经理叫他修改bug，不得已出来
  • 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束                    案例：没有正常的完事，发现忘带纸,不得已出来
  • 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。           案例：没有正常完事,觉得需要酝酿下，所以出来等会再进去
     

（2）以下操作不会释放锁

  • 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。            案例：上厕所，太困了，在坑位上眯了一会
  • 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。

提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用

--------------------------------------------------------线程结束-------------------------------------------------------------

wo-yu
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java--多线程Thread(实现，并发并行，同步死锁，单例，线程组池)
MinggeQingchun的博客
03-12 3053
一、线程 线程是程序执行的一条路径, 一个进程中可以包含多条线程 多线程并发执行可以提高程序的效率, 可以同时完成多项工作 二、多线程并行和并发的区别 1、并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU) 2、并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行， 由于时间间隔较短，使人感觉两个
Java 线程状态之 RUNNABLE
Just do IT
03-21 3761
深入探讨了 Java 线程的 RUNNABLE 状态, 特别是对处在 IO 阻塞时的状态进行了深入分析.
深入理解Runnable接口及其在Java并发编程中的应用
最新发布
m0_46413639的博客
06-03 356
Java中的Runnable接口是并发编程的基础，它提供了一种简单的方式来创建可运行的任务，这些任务可以在单独的线程中执行。当创建一个线程时，可以将实现了Runnable接口的对象作为参数传递给Thread类的构造函数，然后调用线程的start()方法，这样就可以在新的线程中执行run()方法中的代码。通过实现Runnable接口，我们可以在继承其他类的同时，还能让类的实例被线程执行，从而避免了继承上的限制。实现Runnable接口的类只负责定义任务，而线程的创建和管理的逻辑可以由其他类负责。
Java从入门到放弃26---线程的三种创建方式之实现Runnable接口
DOGIOOH的博客
06-03 2889
Java从入门到放弃26—线程的三种创建方式之实现Runnable接口 01 Runnable接口 Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。Runnable 为非 Thread 子类的类提供了一种激活方式。通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread ...
一文搞懂Java多线程，讲的很详细，收藏起来慢慢看
兴趣是最好的老师，勤能补拙
07-05 1976
多线程是指在一个程序中同时执行多个线程，每个线程都有自己独立的执行路径。在多线程中，程序的执行可以同时进行多个任务，从而提高系统的资源利用率和响应性能。在传统的单线程编程模型中，程序按照顺序执行，一次只处理一个任务。这种方式在某些情况下可能会导致效率低下或者无法满足需求。而多线程通过将任务拆分为多个子任务，并且在不同的线程上同时执行，从而实现并发处理。
Runnable接口
fs2424的博客
08-11 1494
方法，可以将自己的代码逻辑与线程分离，使得代码更加模块化和可复用。同时，这样的设计也符合面向对象的原则。接口还可以通过lambda表达式或匿名内部类的方式实现。这使得在使用多线程时更加便捷灵活。是一个接口，在Java中用于表示可以被线程执行的任务。它是实现多线程的一种方式，通过实现。方法是线程执行的入口，其中包含要在线程中执行的代码逻辑。方法，可以描述线程要执行的具体操作。接口中，只定义了一个抽象方法。方法会在新的线程上执行。
Java之线程池详解
weixin_43960447的博客
05-03 430
在创建的线程池中，如有100个线程任务，核心数为10，最大线程数为20，队列大小为10，当执行100个任务是，会在第31个线程触发拒绝策略异常，因为最大线程20+队列10=30，执行31个任务就触发了拒绝策略。在创建了线程池后，当有请求任务进来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放入缓存队列中。内存溢出问题：因为队列的的大小是int最大值，队列线程太多容易出现内存溢出，因为线程队列任务满了。
人工智能-项目实践-多线程-Paxos算法的多线程实现.zip
01-04
在Java中，多线程是并发编程的基础，通过创建Thread对象或者实现Runnable接口，可以开启新的执行线程。在Paxos算法的多线程实现中，通常会为每个节点（如Acceptor、Proposer或Learner）创建独立的线程，以模拟它们...
JAVA-multithreaded-programming.rar_Java @multithreaded_java prog
09-19
在Java中，多线程通过实现Runnable接口或继承Thread类来创建。下面我们将深入探讨Java多线程编程的核心概念、创建方式、线程同步以及实例应用。 1. **线程的基本概念** - **线程**：线程是操作系统分配CPU时间的...
Java多线程批量数据导入的方法详解.rar
03-21
在Java中，我们可以通过继承Thread类或实现Runnable接口来创建线程。多线程并行处理数据，可以将大任务拆分成多个小任务，每个线程负责一部分数据的导入，从而减少整体的处理时间。 批量数据导入时，通常我们会使用...
java多线程Thread-per-Message模式详解
08-27
在Java多线程编程中，Thread-per-Message模式是一种常见的并发处理策略。这种模式的核心思想是为每个消息或任务创建一个新的线程来处理，使得消息的发送者和处理者不在同一个线程上下文中运行，从而实现任务的异步...
java多线程Runnable实例
01-24
java多线程runnable实例，经过测试的，可以直接运行
狂神说多线程详解.rar
05-06
1. `Runnable`接口和`Thread`类：Java中创建线程的两种方式，前者适用于不继承`Thread`的情况。 2. `synchronized`关键字：用于保证线程安全，提供方法和代码块级别的互斥。 3. `volatile`关键字：确保共享变量的...
Java线程基础知识汇总（超详细版）
HSQdePYZ的博客
07-17 661
进程是指在计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。一个进程可以包含多个线程，每个线程都共享该进程的资源，如内存、文件和打开的网络连接等。每个进程都有自己的地址空间，即独立的内存区域。线程是进程内的执行单元，也是CPU的最小执行单元。一个进程可以包含多个线程，每个线程执行不同的任务。线程共享进程的资源，包括内存、文件和打开的网络连接等。线程之间通过共享内存进行通信，因此比进程间通信更高效。由于线程共享同一进程的地址空间，所以多线程之间的切换更快。
java线程初理解、单线程案例
m0_45877477的博客
06-08 403
并发:两个及以上事件,在同一时间段内发生(交替执行:一个人吃2个馒头) → 速度慢 并行:两个及以上事件,在同一时刻发生 (同时执行:两个人吃2个馒头) → 速度快 内存:临时存储RAM (所有的应用程序都需要进入到内存中执行) 硬盘:永久存储 ROM 进程:进入到内存的程序 → 正在运行的电脑管家这个程序 线程:线程属于进程,是进程中的一个执行单元(一个进程有1到多个线程) → 电脑管家里面的不同功能:病毒查杀、清理垃圾、电脑加速 ..
Java--多线程之并发，并行，进程，线程（一）
MinggeQingchun的博客
03-12 2500
以下对并发、并行、进程、线程的理解引自 阿里巴巴技术专家Hollis Java并发编程 一、并发 并发（Concurrent），在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。 无论是Windows、Linux还是MacOS等其实都是多用户多任务分时操作系统。使用这些操作系统的用户是可以“同时”干多件事的 二、并行 并行（Parallel），当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进.
Java_线程 Thread类 Runnable接口 多线程原理 线程安全 线程同步机制 线程状态
劉某人゜的博客
08-26 447
一.线程 1.概述 线程: 进程内部的一个独立执行单元；一个进程可以同时并发的运行多个线程，可以理解为一个进程便相当 于一个单 CPU 操作系统，而线程便是这个系统中运行的多个任务。 进程： 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多 个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创 建、运行到消亡...
Java多线程——Thread的run与start方法
qq_43985303的博客
02-11 1072
调用start()方法，会启动新的线程，并且会让一个线程进入就绪状态，在调度系统分配时间片后，start()会进行相应的准备工作，然后执行run()方法内的内容。而如果直接调用run()方法，只是在主线程运行run()方法，无法起到多线程的效果。当我们使用Thread的时候，想要启动线程，都会调用start()方法，而不是直接调用run()方法。那么为何不直接调用run()方法呢？target 就是 传进来的Runnable。
JAVA多线程（通过 Callable 和 Future 创建线程）
qq_41985556的博客
05-16 1565
创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新...
多线程学习笔记.docx
06-16
Java提供了多种同步机制，如synchronized关键字、wait()和notify()方法、Lock接口以及相关的实现类如ReentrantLock。这些机制可以帮助开发者控制线程的执行顺序，确保共享资源的安全访问。 生产者消费者模式是一种...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值