JUC2-线程

已于 2024-08-15 17:42:27 修改
阅读量1k 收藏 13
点赞数 25
分类专栏： JUC并发编程 文章标签： java 并发编程
于 2024-08-15 17:40:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73902080/article/details/141211774
版权

目录

创建和运行线程

方法一：直接使用Thread

方法二：使用Runnable配合Thread

原理：Thread与Runnable的关系

方法三：FutureTask配合Thread

多个线程同时运行

查看进程线程

原理：线程运行

栈与栈帧

​编辑线程上下文切换（Thread Context Switch）

常用方法

start与run

调用run

调用start

对比

sleep与yield

sleep

yield

对比

sleep应用：限制对CPU的使用

线程优先级

join

概述

应用：同步

interrupt

打断sleep，wait，join的线程

打断正常运行的线程

打断park线程

终止模式：两阶段终止模式

错误思路

两阶段终止模式

不推荐使用的方法

主线程与守护线程

线程的状态

操作系统层面（五种）

Java API层面（六种）

创建和运行线程

方法一：直接使用Thread

例如：

方法二：使用Runnable配合Thread

把线程和任务（要执行的代码）分开

  • Thread代表线程
  • Runnable可运行的任务（线程要执行的代码）

例如：

Java8后使用Lambda精简代码：

原理：Thread与Runnable的关系

  • 方法一是线程和任务合并，方法二是线程和任务分开
  • 用Runnable更容易与线程池等高级API配合
  • 用Runnable让任务类脱离了Thread继承体系，更灵活

方法三：FutureTask配合Thread

FutureTask能接收Callable类型的参数，用来处理有返回结果的情况

多个线程同时运行

  • 交替执行
  • 先后顺序不受控制
import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.TestMultiThread")
public class TestMultiThread {

    public static void main(String[] args) {
        new Thread(() -> {
            while(true) {
                log.debug("running");
            }
        },"t1").start();
        new Thread(() -> {
            while(true) {
                log.debug("running");
            }
        },"t2").start();
    }
}

查看进程线程

windows：

  • 任务管理器可以查看进程和线程数，也可以杀死进程
  • tasklist 查看进程
  • taskkill 杀死进程

linux：

  • ps -fe 查看所有进程
  • ps -fT -p <PID> 查看某个进程（PID）的所有线程
  • kill 杀死进程
  • top 显示所有线程
  • top -H -p <PID> 查看某个进程（PID）的所有线程

Java：

  • jps 查看所有Java进程
  • jstack <PID> 查看某个Java进程（PID）的所有线程状态
  • jconsole 查看某个Java进程中线程的运行情况（图形界面）

原理：线程运行

栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）

每个线程启动后，虚拟机就会为其分配一块栈内存

  • 每个栈由多个栈帧（Frame）组成，对应每次方法调用时所占用的内存
  • 每个线程只能有一个活动栈帧，对应当前正在执行的方法
  • 方法调用执行结束，对应的栈内存会释放
public class TestFrames {
    public static void main(String[] args) {
        method1(10);
    }

    private static void method1(int x) {
        int y = x + 1;
        Object m = method2();
        System.out.println(m);
    }

    private static Object method2() {
        Object n = new Object();
        return n;
    }
}


线程上下文切换（Thread Context Switch）

导致cpu不再执行当前的线程，转而执行另一个线程的原因：

  • 线程的cpu时间片用完
  • 垃圾回收
  • 有更高优先级的线程需要运行
  • 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法

当上下文切换发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条jvm指令的执行地址，是线程私有的

状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等

上下文切换频繁发生会影响性能

常用方法

方法名static功能说明注意
start()启动一个新线程，在新的线程运行 run 方法中的代码start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它），每个线程对象的 start方法只能调用一次，如果调用了多次会出现 IllegalThreadStateException
run()新线程启动后会调用的方法

如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作，但可以创建 Thread 的子类对象，来覆盖默认行为

join()等待线程运行结束
join(long n)等待线程运行结束,最多等待 n 毫秒
getId()获取线程长整型的 idid 唯一
getName()获取线程名
setName(String)修改线程名
getPriority()获取线程优先级
setPriority(int)修改线程优先级java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率
getState()获取线程状态Java 中线程状态是用 6 个 enum 表示，分别为：NEW,RUNNABLE, BLOCKED, WAITING,TIMED_WAITING,TERMINATED
isInterrupted()判断是否被打断不会清除打断标记
isAlive()线程是否存活（还没有运行完毕）
interrupt()打断线程如果被打断线程正在sleep，wait，join会导致被打断的线程抛出 InterruptedException，并清除打断标记 ；如果打断的正在运行的线程，则会设置打断标记 ；park的线程被打断，也会设置打断标记
interrupted()static判断当前线程是否被打断会清除打断标记
currentThread()static获取当前正在执行的线程
sleep(long n)static让当前执行的线程休眠n毫秒，休眠时让出 cpu的时间片给其它线程
yield()static提示线程调度器让出当前线程对cpu的使用主要是为了测试和调试

start与run

调用run

import cn.itcast.Constants;
import cn.itcast.n2.util.FileReader;
import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test4")
public class Test4 {

    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
                FileReader.read(Constants.MP4_FULL_PATH);
            }
        };

        t1.run();
        log.debug("do other things...");
    }
}

程序仍在main线程运行，FileReader.read()方法调用还是同步的

调用start

import cn.itcast.Constants;
import cn.itcast.n2.util.FileReader;
import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test4")
public class Test4 {

    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
                FileReader.read(Constants.MP4_FULL_PATH);
            }
        };

        t1.start();
        log.debug("do other things...");
    }
}

程序在t1线程运行，FileReader.read()方法调用是异步的

调用start()后线程的状态：

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test5")
public class Test5 {

    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };

        System.out.println(t1.getState());
        t1.start();
        System.out.println(t1.getState());
    }
}

注意：start()不能被多次调用

对比

1.直接调用run是在主线程中执行了run，没有启动新的线程

2.使用start是启动新的线程，通过新的线程间接执行run中的代码

sleep与yield

sleep

1.调用sleep会让当前线程从Running进入Timed Waiting状态（阻塞）

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test6")
public class Test6 {

    public static void main(String[] args) {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        t1.start();
        log.debug("t1 state: {}", t1.getState());

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state: {}", t1.getState());
    }
}

2.其他线程可以使用interrupt方法打断正在睡眠的线程，这时sleep方法会抛出InterruptedException

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test7")
public class Test7 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("enter sleep...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    log.debug("wake up...");
                    e.printStackTrace();
                }
            }
        };
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt...");
        t1.interrupt();
    }
}

3.睡眠结束后的线程未必会立刻得到执行

4.建议用TimeUnit的sleep代替Thread的sleep来获得更好的可读性

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

@Slf4j(topic = "c.Test8")
public class Test8 {

    public static void main(String[] args) throws InterruptedException {
        log.debug("enter");
        TimeUnit.SECONDS.sleep(1);
        log.debug("end");
//        Thread.sleep(1000);
    }
}

yield

1.调用yield会让当前线程从Running进入Runnable就绪状态，然后调度执行其他线程

2.具体的实现依赖于操作系统的任务调度器

对比

1.就绪状态有机会获得时间片，阻塞状态不能获得时间片

2.sleep有休眠时间，yield没有

sleep应用：限制对CPU的使用

在没有利用cpu来计算时，不要让while(true)空转浪费cpu，这时可以使用yield或sleep来让出cpu的使用权给其他程序

可以用wait或条件变量达到类似的效果

不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景

sleep适用于无需锁同步的场景

线程优先级

线程优先级会提示调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它

如果cpu比较忙，那么优先级高的线程会获得更多的时间片，但cpu闲时，优先级几乎没作用

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test9")
public class Test9 {

    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
//                Thread.yield();
                System.out.println("              ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.setPriority(Thread.MIN_PRIORITY);//线程1优先级低
        t2.setPriority(Thread.MAX_PRIORITY);//线程2优先级高
        t1.start();
        t2.start();
    }
}

join

概述

下面的代码执行，打印 r 是什么？

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.Test10")
public class Test10 {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        },"t1");
        t1.start();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

分析：

因为主线程和线程t1是并行执行的，t1线程需要1秒之后才能算出r=10，而主线程一开始就要打印r的结果，所以只能打印出r=0

解决方法：

用join，加在t1.start()之后即可

join：等待线程运行结束

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.Test10")
public class Test10 {
    static int r = 0;
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
    private static void test1() throws InterruptedException {
        log.debug("开始");
        Thread t1 = new Thread(() -> {
            log.debug("开始");
            sleep(1);
            log.debug("结束");
            r = 10;
        },"t1");
        t1.start();
        t1.join();
        log.debug("结果为:{}", r);
        log.debug("结束");
    }
}

应用：同步

多线程同步：

import lombok.extern.slf4j.Slf4j;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.TestJoin")
public class TestJoin2 {
    static int r1 = 0;
    static int r2 = 0;

    public static void main(String[] args) throws InterruptedException {
        test2();
    }

    private static void test2() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(1);
            r1 = 10;
        });
        Thread t2 = new Thread(() -> {
            sleep(2);
            r2 = 20;
        });
        t1.start();
        t2.start();
        long start = System.currentTimeMillis();
        log.debug("join begin");
        t2.join();
        log.debug("t2 join end");
        t1.join();
        log.debug("t1 join end");
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }

}

分析：

第一个join：等待t1时，t2并没有停止，而在运行

第二个join：1s后，t1执行完毕，t2也运行了1s，因此只需再等待1s，共2s

颠倒两个join结果也是2s

限时同步：

没等够时间 1500

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    static int r1 = 0;
    static int r2 = 0;

    public static void main(String[] args) throws InterruptedException {
        test3();
    }

    public static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(2);
            r1 = 10;
        });

        long start = System.currentTimeMillis();
        t1.start();

        // 线程执行结束会导致 join 结束
        log.debug("join begin");
        t1.join(1500);
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}

等够时间 3000

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.TestJoin")
public class TestJoin {
    static int r1 = 0;
    static int r2 = 0;

    public static void main(String[] args) throws InterruptedException {
        test3();
    }

    public static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            sleep(2);
            r1 = 10;
        });

        long start = System.currentTimeMillis();
        t1.start();

        // 线程执行结束会导致 join 结束
        log.debug("join begin");
        t1.join(3000);
        long end = System.currentTimeMillis();
        log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
    }
}

interrupt

打断sleep，wait，join的线程

这几个方法都会让线程进入阻塞状态

打断sleep的线程，会清空打断状态

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test11")
public class Test11 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("sleep...");
            try {
                Thread.sleep(5000); // wait, join
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1");

        t1.start();
        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
        log.debug("打断标记:{}", t1.isInterrupted());
    }
}

打断正常运行的线程

打断正常运行的线程，不会清空打断状态

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test12")
public class Test12 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while(true) {
                boolean interrupted = Thread.currentThread().isInterrupted();
                if(interrupted) {
                    log.debug("被打断了, 退出循环");
                    break;
                }
            }
        }, "t1");
        t1.start();

        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
    }
}

打断park线程

打断park线程，不会清空打断状态

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.LockSupport;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.Test14")
public class Test14 {

    public static void main(String[] args) throws InterruptedException {
        test3();
    }

    private static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();

        sleep(1);
        t1.interrupt();
    }

}

如果打断标记已经是true，则park会失效

package cn.itcast.test;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.LockSupport;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.Test14")
public class Test14 {

    public static void main(String[] args) throws InterruptedException {
        test3();
    }

    private static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());

            LockSupport.park();
            log.debug("unpark...");
        }, "t1");
        t1.start();

        sleep(1);
        t1.interrupt();
    }

}

可以使用 Thread.interrupted() 清除打断状态，重置为false

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.locks.LockSupport;

import static cn.itcast.n2.util.Sleeper.sleep;

@Slf4j(topic = "c.Test14")
public class Test14 {

    public static void main(String[] args) throws InterruptedException {
        test3();
    }

    private static void test3() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.interrupted());

            LockSupport.park();
            log.debug("unpark...");
        }, "t1");
        t1.start();

        sleep(1);
        t1.interrupt();
    }

}

终止模式：两阶段终止模式

Two Phase Termination

在一个线程T1中如何“优雅”终止线程 T2？这里的【优雅】指的是给T2一个料理后事的机会

错误思路

使用线程对象的stop()方法停止线程

  • stop方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其他线程将永远无法获取锁

使用System.exit(int)方法停止线程

  • 目的仅是停止一个线程，但这种做法会让整个程序都停止
两阶段终止模式

interrupt实现：

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.TwoPhaseTermination")
public class Test13 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();

        Thread.sleep(3500);
        tpt.stop();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
    // 监控线程
    private Thread monitorThread;

    // 启动监控线程
    public void start() {

        monitorThread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                // 是否被打断
                if (current.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //重新设置打断标记
                    current.interrupt();
                }
            }
        }, "monitor");
        monitorThread.start();
    }

    // 停止监控线程
    public void stop() {
        monitorThread.interrupt();
    }
}

不推荐使用的方法

这些方法已经过时，容易破坏同步代码块，造成线程死锁

主线程与守护线程

默认情况下，Java进程需要等待所有线程都运行结束才会结束，有一种特殊的线程叫做守护线程，只要其他非守护线程运行结束，即使守护线程的代码没有执行完，也会强制结束

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test15")
public class Test15 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    break;
                }
            }
            log.debug("结束");
        }, "t1");
        //设置t1为守护线程
        t1.setDaemon(true);
        t1.start();

        Thread.sleep(1000);
        log.debug("结束");
    }
}

注意：

  • 垃圾回收器线程就是一种守护线程
  • Tomcat中的 Acceptor 和 Poller 线程都是守护线程，所以Tomcat接收到shutdown命令后，不会等待它们处理完当前请求

线程的状态

操作系统层面（五种）

1.初始状态：仅是在语言层面创建了线程对象，还未与操作系统线程关联

2.可运行状态（就绪状态）：该线程已经被创建（与操作系统线程关联），可以由cpu调度执行

3.运行状态：获取了cpu时间片运行中的状态

  • 当cpu时间片用完，会从运行状态转换至可运行状态，会导致线程的上下文切换

4.阻塞状态：如果调用了阻塞API，如BIO读写文件，这时该线程实际不会用到cpu，会导致线程上下文切换，进入阻塞状态，等BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至可运行状态

  • 与可运行状态的区别是：对于阻塞状态的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

5.终止状态：表示线程已经执行完毕，生命周期已经结束，不会再转换为其他状态

Java API层面（六种）

根据Thread.State枚举，分为六种状态

1.NEW：线程刚被创建，但还没有调用start()方法

2.RUNNABLE：调用了start()方法后

  • Java API层面的RUNNABLE状态涵盖了操作系统层面的可运行状态、运行状态和阻塞状态（由于BIO导致的线程阻塞，在Java里无法区分，仍然认为是可运行）

3.BLOCKED

4.WAITING

5.TIMED_WAITING

6.TERMINATED：线程代码运行结束

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;

@Slf4j(topic = "c.TestState")
public class TestState {
    public static void main(String[] args) throws IOException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };

        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while(true) { // runnable

                }
            }
        };
        t2.start();

        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        t3.start();

        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000); // timed_waiting
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();

        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join(); // waiting
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (TestState.class) { // blocked
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state {}", t1.getState());
        log.debug("t2 state {}", t2.getState());
        log.debug("t3 state {}", t3.getState());
        log.debug("t4 state {}", t4.getState());
        log.debug("t5 state {}", t5.getState());
        log.debug("t6 state {}", t6.getState());
        System.in.read();
    }
}

 

Onlooker129
关注
专栏目录
JUC学习 - 线程6种状态详解
TyuIn的博客
12-01 506
1、线程状态分类 线程一共有六种状态，分别为New、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED，同一时刻只有一种状态，通过线程的getState方法可以获取线程的状态。 2、状态详解 Thread的状态使用java.lang.Thread.State枚举表示。 public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMI
JUC并发----线程和进程
abaidaye的博客
11-12 390
1.1.进程和线程的概念 什么是进程？ 可以理解为，进程就是存储在静态资源（磁盘）里的程序（指令和数据）运行时的一种状态，通俗的理解，进程就是运行时的程序。 注释：程序由数据和指令组成，这些指令要读写，就必须把指令加载到cpu，数据加载到内存 。进程就是来加载指令，管理内存，管理io的 注意：内存一般指的是运行内存，因为小时候不准确的概念，我们常常将内存和磁盘存储相关联，但二者不相同。 当一个程序被调用时，它就作为一个进程，从磁盘加载到内存之中。一个程序可以有多个进程（记事本）也可以只有一个进程（网
JUC笔记-线程
weixin_50255400的博客
01-18 354
JUC-线程一、进程线程、并行并发、同步异步概念1.1 进程与线程1.2 并发与并行1.3 同步与异步二、线程的创建（重点）2.1 通过继承Thread创建线程2.1 使用Runnable配合Thread (推荐)2.3 使用FutureTask与Thread结合（Callable接口）三、线程运行原理（重点）3.1 虚拟机栈与栈帧3.2 线程上下文切换（Thread Context Switch)3.3 线程的常用方法3.3.1 start 与 run方法的区别3.3.2 sleep 与 yield3.3
剑指JUC原理-2.线程
爱吃知识的土豆倪的博客
10-25 237
Thread是把线程和任务合并在了一起，Runnable是把线程和任务分开了用 Runnable 更容易与线程池等高级 API 配合用 Runnable 让任务类脱离了 Thread 继承体系，更灵活。
JUC-线程调度
孟孟的博客
01-17 315
package org.meng.juc; import java.util.Random; import java.util.concurrent.Callable; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; .
JUC--006--locks2
RuleBreaker
03-04 2678
接着上篇 调用 countDownLatch.await(); 的线程，创建了 Node， 并添加到 双向链表中。 而且将自己的前置节点的状态设置成 SINGAL 状态，接着自己就阻塞在 unsafe.park 上。 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ countDownLatch.countDown(); 的执行： //CountDownLatch::countDown.
juc6-多线程基础
u012222011的博客
03-10 111
多线程概念： 定义多线程方法： 1.thread使用方法 自定义线程类继承Thread类 重写run方法，编写线程执行体 在主线程中创建线程对象，使用start方法启动线程 Runnable 接口 自定义MyRunable类实现Runable接口 重写run方法，编写线程执行体 在主线程中创建线程对象，使用start方法启动线程 对个线程操作同一个资源的时候，线程不安全，数据会紊乱 .Callable使用方法 通过服务提交..
JUC-线程基础概念
weixin_47251999的博客
02-05 178
java中线程 Thread中方法 判断一个线程是否存活：thread引用.isAlive(); 阻塞当前线程： Thread.sleep(lang millis); 线程六大状态 由Thread.State枚举类定义！ 由thread.getState()方法获得当前线程状态。
JUC-线程安全问题
weixin_47251999的博客
02-05 169
由于不可见会导致的问题是：一个线程从主内存中读取数据后，对数据修改后并不立即刷新到主内存上（而是自己继续用）导致其他线程一直读取的是主内存中的旧数据。
JUC-进程和线程
诗和远方，代码和你
07-21 305
进程：程序是静止的，进程实体的运行过程就是进程，是系统进行资源分配的基本单位进程的特征：并发性、异步性、动态性、独立性、结构性线程：线程是属于进程的，是一个基本的 CPU 执行单元，是程序执行流的最小单元。线程是进程中的一个实体，是系统独立调度的基本单位，线程本身不拥有系统资源，只拥有一点在运行中必不可少的资源，与同属一个进程的其他线程共享进程所拥有的全部资源关系：一个进程可以包含多个线程，这就是多线程，比如看视频是进程，图画、声音、广告等就是多个线程线程的作用：使多道程序更好的并发执行，提高资源利用率和系
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶 Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC...
JUC学习 - 线程的基本操作
TyuIn的博客
11-25 200
一、新建线程 新建线程很简单。只需要使用new关键字创建一个线程对象，然后调用它的start()启动线程即可。 Thread thread1 = new Thread(); thread1.start(); 那么线程start()之后，会干什么呢？线程有个run()方法，start()会创建一个新的线程并让这个线程执行run()方法。 这里需要注意，下面代码也能通过编译，也能正常执行。但是，却不能新建一个线程，而是在当前线程中调用run()方法，将run方法只是作为一个普通的方法调用。 Thread th
JUC学习 - 线程组 ThreadGroup
TyuIn的博客
11-25 125
一、线程组 我们可以把线程归属到某个线程组中，线程组可以包含多个线程以及线程组，线程和线程组组成了父子关系，是个树形结构，如下图： 使用线程组可以方便管理线程，线程组提供了一些方法方便方便我们管理线程。 1、创建线程关联线程组 创建线程的时候，可以给线程指定一个线程组，代码如下： public class ThreadGroupDemo { public static class R1 implements Runnable { public void
Java-网络
2301_81543552的博客
09-14 696
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 603
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 277
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1136
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
最新发布
xiaocaij_icai的博客
09-15 187
");
基于SpringBoot的考研资讯平台设计与实现
linzhongshu的专栏
09-13 920
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
Java-JUC-多线程进阶是一门关于Java并发编程的课程，来源于B站的《遇见狂神说》。这门课程于2019年5月31日发布，主要涵盖了以下主题：JUC的概念，进程和线程的回顾，Lock锁的使用，生产者和消费者模式，8锁的现象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值