Java学习笔记===》25.多线程

最新推荐文章于 2024-08-06 10:22:43 发布
最新推荐文章于 2024-08-06 10:22:43 发布
阅读量51 收藏
点赞数
分类专栏： 学习笔记 文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59318477/article/details/131314113
版权

多线程

一、什么是多线程

1.多线程：

线程： 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的是合计运作单位

简单理解：就是应用软件中互相独立，可以同时运行的而功能，而多个线程同时运行，就是多线程

**进程：**进程是程序的基本执行实体

（1）多线程的作用

提高代码或程序的运行效率，

（2）多线程的应用场景

软件中的耗时操作：比如说拷贝迁移大文件、加载大量的资源文件、所有的聊天软件、所有的服务器

二、多线程的两个概念

1.并发

并发：在同一时刻，有多条指令在单个cpu上**交替**运行

2.并行

并行：在同一时刻，有多个指令在多个cpu上**同时**执行

三、多线程的实现方式

1.继承Thread类的方式进行实现

优点：编程比较简单，可以直接使用Thread类中的方法

缺点：可扩展性交叉，不能再继承其他的类

package com_09MultiThread._01threadCase01;

public class MyThread extends Thread{


    //重写run方法

    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"helloworld");
        }
    }
}
//测试类
package com_09MultiThread._01threadCase01;

public class Test01 {
    public static void main(String[] args) {
        /*
        * 多线程的第一种启动方式
        *步骤：
        *   1.自己定义一个类继承Thread
        *   2.重写里面的run方法
        *   3.创建子类的对象，并启动线程
        * */
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("线程1");
        t1.setName("线程2");
        //开启线程
        t1.start();
        t2.start();
    }
}

2.实现Runnable接口的方式进行实现

优点：扩展性强，实现该接口的同时还可以继承其他的类

缺点：编程相对复杂，不能直接使用Thread类中的方法

package com_09MultiThread._02threadCase02;

public class MyRun implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //获取当前线程的对象
            /*Thread t = Thread.currentThread();
            System.out.println(t.getName()+"helloworld");*/

            System.out.println(Thread.currentThread().getName()+"helloworld");
        }
    }
}
//测试类
package com_09MultiThread._02threadCase02;

public class Test {
    public static void main(String[] args) {
        /*
        * 多线程的而第二种启动方式
        * 步骤：
        *   1.自己定义一个类实现Runnable接口
        *   2.重写里面的run方法
        *   3.创建自己类的对象
        *   4.创建一个Thread类的对象，并开启线程
        * */
        //创建类的对象
        //表示多线程要执行的任务
        MyRun mr = new MyRun();

        //创建多线程对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        t1.setName("线程1");
        t2.setName("线程2");

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

3.利用Callable接口和Future接口方式实现

优点：扩展性强，实现该接口的同时还可以继承其他的类

缺点：编程相对复杂，不能直接使用Thread类中的方法

package com_09MultiThread._03threadCase03;

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {


    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            sum = sum + i;
        }
        return sum;

    }
}

//
package com_09MultiThread._03threadCase03;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        * 多线程的第三种实现方式：
        *   特点：可以获取到多线程运行的结果
        *   1.创建一个MyCallable的类实现Callable接口
        *   2.重写Call方法（是有返回值的，表示多线程运行的结果）
        *
        *   3.创建FutureTask的对象 作用管理多线程运行的结果
        *   4.创建MyCallable对象，表示多线程要执行的任务
        *   5.床架Thread对象并启动（表示线程）
        * */

        //1.创建MyCallable的对象
        MyCallable mc = new MyCallable();

        //2.创建FutureTask的对象
        FutureTask<Integer> ft = new FutureTask(mc);

        //3.创建线程的对象
        Thread t = new Thread(ft);

        //4.启动线程
        t.start();

        //5.获取多线程运行的结果
        Integer result = ft.get();
        System.out.println(result);
    }
}

四、常见的成员方法

方法名称说明
String getName（）返回此线程的名称
void setName（String name）设置线程的名字（构造方法也可以设置名字）
static Thread currentThread（）获取当前线程的对象
static void sleep（long time）让线程休眠指定的时间，单位为毫秒
setPriority （int newPriority）设置线程的优先级
final intPriority（）获取线程的优先级
final void setDaemon（boolean on）设置为线程守护
public static void yield（）出让线程/礼让线程
public static void join（）插入线程/插队线程

（1）获取/设置线程名称/对象

package com_09MultiThread._04ThreadMethod;

public class MyThread extends Thread{

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"@"+i);
        }
    }
}
//测试类
package com_09MultiThread._04ThreadMethod;

public class Test {
    public static void main(String[] args) throws InterruptedException {
/*#
| 方法名称                           | 说明                                     |
| ---------------------------------- | ---------------------------------------- |
| String getName（）                 | 返回此线程的名称                         |
| void setName（String name）        | 设置线程的名字（构造方法也可以设置名字） |
| static Thread currentThread（）    | 获取当前线程的对象                       |
| static void sleep（long time）     | 让线程休眠指定的时间，单位为毫秒         |
| setPriority （int newPriority）    | 设置线程的优先级                         |
| final intPriority（）              | 获取线程的优先级                         |
| final void setDaemon（boolean on） | 设置为线程守护                           |
| public static void yield（）       | 出让线程/礼让线程                        |
| public static void join（）        | 插入线程/插队线程                        |*/


/*
            String getName()                    返回此线程的名称
            void setName(String name)           设置线程的名字（构造方法也可以设置名字）
            细节：
                1、如果我们没有给线程设置名字，线程也是有默认的名字的
                        格式：Thread-X（X序号，从0开始的）
                2、如果我们要给线程设置名字，可以用set方法进行设置，也可以构造方法设置

            static Thread currentThread()       获取当前线程的对象
            细节：
                当JVM虚拟机启动之后，会自动的启动多条线程
                其中有一条线程就叫做main线程
                他的作用就是去调用main方法，并执行里面的代码
                在以前，我们写的所有的代码，其实都是运行在main线程当中

            static void sleep(long time)        让线程休眠指定的时间，单位为毫秒
            细节：
                1、哪条线程执行到这个方法，那么哪条线程就会在这里停留对应的时间
                2、方法的参数：就表示睡眠的时间，单位毫秒
                    1 秒= 1000毫秒
                3、当时间到了之后，线程会自动的醒来，继续执行下面的其他代码
       */

        //1.创建线程的对象
        MyThread t1 = new MyThread("飞机");
        MyThread t2 = new MyThread("坦克");



        //2.开启线程
        t1.start();
        t2.start();


        //哪条线程执行到这个方法，此时获取的就是哪条线程的对象
        Thread t = Thread.currentThread();
        String name = t.getName();
        System.out.println(name);//main*/

        System.out.println("11111111111");
        Thread.sleep(5000);
        System.out.println("22222222222");


    }
}

（2）线程的优先级

程序的调度：

抢占式调度：线程随机抢夺cpu的资源

非抢占式调度：所有线程轮流被cpu执行，z

在Java中，采用的是抢占式调度

| setPriority （int newPriority） | 设置线程的优先级 |
| final intPriority（） | 获取线程的优先级 |

优先级越大，抢到cpu的概率越大（范围1-10，10最大，1最小，默认是5）

package com_09MultiThread._05ThreadMethod02;

public class Test {
    public static void main(String[] args) {
        /*
        * | setPriority （int newPriority）    | 设置线程的优先级                         |
        * | final intPriority（）              | 获取线程的优先级                         |
        * */

        //创建线程要执行的参数对象
        MyRunnable mr = new MyRunnable();

        //创建线程对象
        Thread t1 = new Thread(mr,"线程1");
        Thread t2 = new Thread(mr,"线程2");

        //设置线程的优先级
        //优先级越高，抢占cpu的概率越大，
        //但是不一定是优先级越高的线程先执行完（概率）
        t1.setPriority(1);
        t2.setPriority(10);

        //启动线程
        t1.start();
        t2.start();
    }
}

（3）守护线程

package com_09MultiThread._06ThreadMethod03;

public class Test {
    public static void main(String[] args) {
        /*final void setDaemon(boolean on)   设置为守护线程
        *
        * 守护线程的特点：
        *      当其他的非守护线程结束时候，守护线程也会陆续结束，
        *      通俗的说，当非守护线程结束了，那么守护线程也没有存在的必要了
        *
        *
        * */

        //创建线程对象
        MyThread t1 = new MyThread();
        MyThread2 t2 = new MyThread2();

        //设置线程名称
        t1.setName("正常线程");
        t2.setName("守护线程");

        //将t2设置为守护线程
        t2.setDaemon(true);

        t1.start();
        t2.start();
    }
}
//运行结果
守护线程=>0
正常线程=>1
守护线程=>1
守护线程=>2
正常线程=>2
正常线程=>3
正常线程=>4
正常线程=>5
正常线程=>6
正常线程=>7
正常线程=>8
守护线程=>3
守护线程=>4
正常线程=>9
正常线程=>10  //当非守护线程结束之后，守护线程会陆续结束
守护线程=>5
守护线程=>6

（4）礼让线程

package com_09MultiThread._07ThreadMethod04;

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(getName()+"->"+i);
            //出让当前cpu的执行权
            Thread.yield();
            //方法的执行原理：
            //当a线程巧夺到cpu执行完线程，将cpu的执行权出让，再和b线程重新抢夺cpu的执行权
        }
    }
}
//测试类
package com_09MultiThread._07ThreadMethod04;

public class Test {
    public static void main(String[] args) {
        /*public static void yeild()   出让线程/礼让线程
        *
        * 这个方法会让多个线程执行的更加均匀一点，但不是绝对，只是尽可能
        * */

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("a线程");
        t2.setName("b线程");

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

    }
}

（5）插入线程

package com_09MultiThread._08ThreadMethod05;

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            System.out.println(getName()+"->"+i);
        }
    }
}
//测试类
package com_09MultiThread._08ThreadMethod05;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        /*public final void join()      插入线程/插队线程*/


        MyThread t1 = new MyThread();
        t1.setName("小冬瓜");
        t1.start();

        //表示把t1这个线程插入到当前线程之前
        //t1线程：小冬瓜
        //当前线程：main线程
        t1.join();

        //执行在main线程当中的
        for (int i = 0; i <= 10; i++) {
            System.out.println("main线程"+i);
        }
    }
}

五、线程的生命周期

在这里插入图片描述

六、线程安全的问题

需求：某电影院 正在上映国产大片，共有100张票，而它有三个窗口卖票，请设计一个程序模拟电影院卖票

package com_09MultiThread._09ThreadSafe01;

public class MyThread extends Thread{

    //表示这个类所有的对象，都共享ticket数据
    static int ticket = 0; //0~99

    //锁的对象，一定要是唯一的
    static Object obj = new Object();

    @Override
    public void run() {
        while(true){
            //同步代码块
            synchronized (obj){  //括号里面是锁的对象，这个对象可以是任何类型的
                if(ticket<100){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName()+"正在卖"+ticket+"张票");
                }else{
                    break;
                }
            }
        }
    }
}
//测试类
package com_09MultiThread._09ThreadSafe01;

public class Test01 {
    public static void main(String[] args) {
        /*需求：某电影院 正在上映国产大片，共有100张票，而它有三个窗口卖票，请设计一个程序模拟电影院卖票*/

        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }
}

1.同步代码块

@Override
    public void run() {
        while(true){
            //同步代码块
            synchronized (obj){  //括号里面是锁的对象
                    System.out.println(getName()+"正在卖"+ticket+"张票");
                }else{
                    break;
                }
            }
        }

注意：

①这个锁不能写在循环的外面，否则当有一个线程进入循环，锁关闭，其他的线程只能在外面等待，直到循环结束，第二个线程才会开始

②synchronized锁的对象必须是唯一的，否则，跟没有锁一样

while(true){
            //同步代码块
            synchronized (MyThread.class){  //括号里面是锁的对象,一般写成类名.class，因为在同一个文件夹里面，只能有唯一的一个字节码文件
                if(ticket<100){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    ticket++;
                    System.out.println(getName()+"正在卖"+ticket+"张票");
                }else{
                    break;
                }
            }
        }
    }

2.同步方法

同步方法就是把synchronized关键字加上

（1）格式：
修饰符 synchronixed 返回值类型  方法名 （方法参数）{...}
（2）同步方法的特点

①同步方法是锁住方法里面所有的代码

②锁对象不能自己指定（java已经规定好）

​ 非静态：this（当前方法的调用者）

​ 静态：当前类的字节码文件对象

需求：某电影院 正在上映国产大片，共有100张票，而它有三个窗口卖票，请设计一个程序模拟电影院卖票

要求：用同步方法完成

package com_09MultiThread._10ThreadSafe02;

public class MyRunnable implements Runnable{
    int ticket = 0;//因为Runnable只会创建一次对象，所以不用写static代码块
    @Override
    public void run() {
        while(true) {
            //同步代码块
                if (method()) break;
        }
    }

    private synchronized boolean method() {
        if (ticket == 100) {
            return true;
        } else {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            ticket++;
            System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
        }
        return false;
    }
}
//测试类
package com_09MultiThread._10ThreadSafe02;

public class Test {
    public static void main(String[] args) {
/*  需求：
        某电影院 正在上映国产大片，共有100张票，而它有三个窗口卖票，请设计一个程序模拟电影院卖票
     要求：
        用同步方法完成
*/

        MyRunnable mr = new MyRunnable();

        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        Thread t3 = new Thread(mr);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

（3）Lock锁

JDK5以后提佛你们过来一个新的锁对象Lock

Lock实现提供比使用Synchronixed方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法

void lock（）：获得锁

void unlock（）：释放锁

lock是接口，不能直接实例化，这里采用他的实现类ReentrantLock来实例化

ReentrantLock的构造方法：ReentrantLock（）：创建一个ReentrantLock的实例

package com_09MultiThread._11ThreadSafe03;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread extends Thread{

    static int ticket = 0;

    static Lock lock= new ReentrantLock();

    @Override
    public void run() {
        while(true){
            lock.lock();
            try {
                if (ticket == 100){
                    break;
                }else{
                    Thread.sleep(100);
                    ticket++;
                    System.out.println(getName()+"正在卖"+ticket+"张票");
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();
            }
        }
    }
}

六、死锁

在代码出现了锁的嵌套时就会出现死锁

死锁不是一个知识点，为是一个错误

package com_09MultiThread._12deadThread;

public class MyThread extends Thread {

    static Object objA = new Object();
    static Object objB = new Object();

    @Override
    public void run() {
        //1.循环
        while (true) {
            if ("线程A".equals(getName())) {
                synchronized (objA) {
                    System.out.println("线程A拿到了A锁，准备拿B锁");//A
                    synchronized (objB) {
                        System.out.println("线程A拿到了B锁，顺利执行完一轮");
                    }
                }
            } else if ("线程B".equals(getName())) {
                if ("线程B".equals(getName())) {
                    synchronized (objB) {
                        System.out.println("线程B拿到了B锁，准备拿A锁");//B
                        synchronized (objA) {
                            System.out.println("线程B拿到了A锁，顺利执行完一轮");
                        }
                    }
                }
            }
        }
    }
}
//测试类
package com_09MultiThread._12deadThread;

public class Test {
    public static void main(String[] args) {
        /*
           需求：
                死锁
       */


        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.setName("线程A");
        t2.setName("线程B");

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

    }
}
//运行结果
线程A拿到了A锁，准备拿B锁
线程B拿到了B锁，准备拿A锁
/*
这段代码的意思就是，有一扇门，有两个锁孔，甲和乙每人都有两把钥匙，但两个人都想单独开这个，甲先把钥匙插进了A锁孔，准备拿钥匙开B锁孔，但是这时候，乙拿钥匙插在了B锁孔，这个时候，甲在等乙把钥匙拿出来，乙也在等甲把钥匙拿出来，导致的结果是，这个门谁也开不了，在程序里面，就是程序卡在了中间不会结束
*/

如何避免死锁：

​ 在带啊吗书写过程中，避免锁的嵌套

七、生产者和消费者（等待唤醒机制）

生产者消费者模式是一个十分经典的多线程协作的模式

1.第一种实现方式—》等待队列方式

常见方法：
方法名称说明
void wait（）当前线程等待，直到被其他线程唤醒
void notify（）随机唤醒等待解决机制
void notifyAll（）唤醒所有线程

（1）消费者代码实现

package com_09MultiThread._13waitAndNotify;

public class consumer extends Thread{
    /*
     * 1. 循环
     * 2. 同步代码块
     * 3. 判断共享数据是否到了末尾（到了末尾）
     * 4. 判断共享数据是否到了末尾（没有到末尾，执行核心逻辑）
     * */
    @Override
    public void run() {
        while(true){
            synchronized (Controller.lock){
                if (Controller.count == 0){
                    break;
                }else{
                    //先判断当前线程是否要执行
                    if(Controller.flag == 0){
                        //如果不执行，就等待
                        try {
                            Controller.lock.wait();//让当前线程和锁进行绑定
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        //如果要执行
                        //要执行的次数-1
                        Controller.count--;
                        //线程执行
                        System.out.println("当前消费者线程正在执行，还能执行"+Controller.count+"次");
                        //执行之后，唤醒生产者线程执行
                        Controller.lock.notifyAll();
                        //修改线程执行时机，让生产者线程执行
                        Controller.flag = 0;
                    }
                }
            }
        }
    }
}

（2）生产者代码实现

package com_09MultiThread._13waitAndNotify;

public class producer extends Thread {
    /*
     * 1. 循环
     * 2. 同步代码块
     * 3. 判断共享数据是否到了末尾（到了末尾）
     * 4. 判断共享数据是否到了末尾（没有到末尾，执行核心逻辑）
     */


    @Override
    public void run() {
        while (true){
            synchronized (Controller.lock){
                if (Controller.count == 0){
                    break;
                }else{
                    //判断生产者线程是否要执行
                    if(Controller.flag == 1){
                        //如果不用执行，就等待
                        try {
                            Controller.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        //如果需要执行，就执行线程
                        System.out.println("生产者线程正在执行");
                        //修改执行实际，让消费者再执行
                        Controller.flag = 1;
                        //唤醒消费者线程
                        Controller.lock.notifyAll();
                    }
                }

            }
        }
    }
}

（3）控制消费者和生产者执行时机代码实现

package com_09MultiThread._13waitAndNotify;

public class Controller extends Thread{
    /*
    * 作用：控制生产者和消费者
    * */

    //控制线程执行的时机，
    public static int flag = 0;

    //要执行的次数
    public static  int count = 10;

    //锁的对象
    public static Object lock = new Object();
}

（4）测试类

package com_09MultiThread._13waitAndNotify;

public class Test {
    public static void main(String[] args) {
        /*
        * 需求：
        *   完成生产者和消费者（等待唤醒机制）的代码
        *   实现线程轮流交替执行的效果
        * */

        //创建线程的对象
        producer p = new producer();
        consumer c = new consumer();

        //给线程设置名字
        p.setName("生产者");
        c.setName("消费者");

        //启动线程
        p.start();
        c.start();
    }
}

2.第二种实现方式—》阻塞队列方式

在这里插入图片描述

（1）阻塞队列的继承结构

在这里插入图片描述

生产者代码实现

package com_09MultiThread._14waitAndNotify;

import java.util.concurrent.ArrayBlockingQueue;

public class producer extends Thread{

    ArrayBlockingQueue<String> queue;

    public producer(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while(true){
            //生产者不断生产数据放到阻塞队列中
            try {
                queue.put("数据");
                System.out.println("生产者生产了一条数据");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }

    }
}

消费者代码实现

package com_09MultiThread._14waitAndNotify;

import java.util.concurrent.ArrayBlockingQueue;

public class consumer extends Thread{
    ArrayBlockingQueue<String> queue;

    public consumer(ArrayBlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while(true){
            //消费者不断地从阻塞队列中获取数据
            try {
                String data = queue.take();
                System.out.println(data);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

测试类

package com_09MultiThread._14waitAndNotify;

import java.util.concurrent.ArrayBlockingQueue;

public class Test {
    public static void main(String[] args) {
        /*
         *
         *    需求：利用阻塞队列完成生产者和消费者（等待唤醒机制）的代码
         *    细节：
         *           生产者和消费者必须使用同一个阻塞队列
         *
         * */

        //1.创建阻塞队列的对象
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);


        //2.创建线程的对象，并把阻塞队列传递过去
        producer p = new producer(queue);
        consumer c = new consumer(queue);

        //3.开启线程
        p.start();
        c.start();
    }
}

八、线程的状态

在这里插入图片描述

注意：在Java的虚拟机中，是没有定义运行状态的，这个状态只是为了方便学习

kinbow_0923
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程源码笔记.pdf
05-08
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统效率。在Java中，实现多线程主要有两种方式：通过继承Thread类和实现Runnable接口。Thread类提供了创建新线程的基本功能，而Runnable...
java分布式应用学习笔记05多线程下的并发同步器.pdf
11-29
在Java分布式应用开发中，多线程环境下的并发同步是至关重要的一个环节。并发同步器在多线程编程中起到协调各个线程访问共享资源，确保数据一致性与程序正确性的关键作用。本篇笔记将深入探讨Java中的并发同步机制，...
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 18万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
JAVA多线程 学习笔记 （持续更新)
zhaoronghao的博客
02-16 1131
java进阶的学习之路
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3264
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
Java学习笔记-多线程
cyh0503的博客
07-08 2808
并发与并行 并发：指两个或多个事件在同一个时间段内发生 并行：指两个或多个事件在同一时刻发生（同时发生） 在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。 而在多个CPU系统中，则这些可以并发执行的程序便可以分配到多...
Java学习笔记---多线程并发
weixin_44823875的博客
03-22 1484
Java学习笔记---多线程并发认识线程和进程java中线程的实现继承Thread类（多线程实现类）实现Runnable接口（==推荐使用==）Thread类和Runnable接口线程的状态线程操作的方法同步与死锁使用同步解决使用死锁解决 认识线程和进程 进程是线程一次动态执行过程，它需要经历从代码加载、代码执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。因为每个进...
Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
热门推荐
qq_35716689的博客
03-16 18万+
异步日志记录是一种提升系统性能和可维护性的有效手段。牵着猫散步的鼠鼠。通过将日志记录操作异步化，不仅可以减少对业务处理流程的影响，还可以提高日志处理的灵活性和扩展性。然而，实现异步日志记录机制也伴随着一定的挑战，如日志的实时性、顺序性和丢失风险等问题。
Java多线程学习笔记
恶魔盒子
11-15 1288
Java多线程学习笔记 1.程序：一段静态的代码。 进程：程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有它自身的产生，存在和消亡的过程。 线程：进程可进一步细化为线程，是程序内部的一个执行路径。 2.线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc）。 一个进程可能有多个线程，多个线程共享相同的内存单元，如图，方法区内是 static的静态方法，堆内是 创建的对象。 3. 一个进程的多个线程共享相同的内存单元，从一个堆中分配对象，可以访问相同的变量和对象，这就使得线
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 931
文章标题
尚硅谷java学习笔记——11.java多线程
无关风月
02-18 1811
1、理解程序、进程、线程的概念 程序可以理解为静态的代码 进程可以理解为执行中的程序 线程可以理解为进程的进一步细分，程序的一条执行路径 使用多线程的优点： 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。 提高计算机系统CPU的利用率 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改 Thread的常用方法： 1、start( ):启动线程
java多线程基础学习[狂神说java-多线程笔记]
Alivorth的博客
11-08 1089
java多线程基础学习一、线程简介1.类比2.程序进程线程3.线程的核心概念二、线程的实现(重点)调用方法与调用多线程的区别Thread 类1.thread使用方法2. 代码实现3.应用Runnable 接口1.Runable使用方法2. 代码实现3.应用Callable接口1.Callable使用方法2.代码实现三、线程的状态线程的5个状态线程方法观察线程的状态线程的优先级守护线程（daemon）四、线程同步同步方法与同步块死锁Lock(锁)五、线程协作生产者消费者模式线程池 一、线程简介 所有的资料来
Java基础 学习笔记 Markdownr版
06-27
4. 多线程：在10多线程.md中，介绍了如何创建和管理Java线程，包括Thread类、Runnable接口，以及同步机制如synchronized关键字、wait()、notify()和notifyAll()方法。多线程技术是实现并发执行的关键，有助于提高...
java学习笔记_多线程.txt
09-29
java学习笔记_多线程.txt，包括死锁的原因和解锁的方法。
多线程-狂神说Java学习笔记
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 500
使用TCP协议支持与多个客户端同时通信。
C++ - 函数重载
最新发布
jiaowenjie的专栏
08-06 269
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
枚举工具类
qq_43049583的博客
08-04 489
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 567
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
时光不等人：java每日一练
m0_67187271的博客
08-05 1045
时光悄然流逝，不等人。技术亦不会自来门前，唯有勤奋学习，方能抓住时代的脉搏。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值