【Java学习】多线程&JUC万字超详解

于 2024-09-01 08:09:39 发布
阅读量785 收藏 20
点赞数 39
分类专栏： Java学习 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2202_76097976/article/details/141572241
版权

 所属专栏：Java学习      

在这里插入图片描述

1. 多线程的概念

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

下面这些每一个能够运行的软件就是一个进程

并发：在同一时刻，有多个指令在单个CPU上交替执行

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

2. 多线程的实现方式

2.1 继承Thread类的方式进行实现

实现方式：

1. 定义一个类，继承Thread

2. 重写run方法

3. 创建子类对象，并启动线程

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName() + "hello");
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        //设置线程对象名称
        t1.setName("线程一：");
        t2.setName("线程二：");
        //开启线程
        t1.start();
        t2.start();
    }
}
 

在开启线程之后，会交替执行线程一和线程二
 

 

2.2 实现Runnable接口的方式进行实现
 

 
 
实现方式：
 

 

  1.  
    自定义一个类，实现Runnable接口
     
  2.  
    重写里面的Run方法
     
  3.  
    创建自定义类的对象
     
  4.  
    创建一个Thread类的对象，并开启线程
     
 

public class MyRun implements Runnable{
    @Override
    public void run() {
        for(int i = 0;i < 10;i++){
            //获取当前线程对象
            Thread t = Thread.currentThread();
            System.out.println(t.getName() + "hello");
        }
    }
}
 

public class ThreadDemo2 {
    public static void main(String[] args) {
        //创建MyRun对象，表示多线程要执行的任务
        MyRun myRun = new MyRun();
        //创建线程的对象
        Thread t1 = new Thread(myRun);
        Thread t2 = new Thread(myRun);
        //给线程设置名字
        t1.setName("线程一：");
        t2.setName("线程二：");
        //开启线程
        t1.start();
        t2.start();
    }
}
 

开启线程之后也是交替执行线程一和线程二
 

 

 

2.3 利用Callable接口和Future接口方式实现
 

实现方式：
 

 
 
1. 创建一个类MyCallable实现Callable接口
 
 
2. 重写call方法（返回值代表多线程运行的结果）
 
 
3. 创建MyCallable对象（表示多线程要执行的任务）
 
 
4. 创建FutureTask对象（作用管理多线程运行的结果）
 
 
5. 创建Thread类的对象并启动（表示线程）
 

 

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 += i;
        }
        return sum;
    }
}
 

public class ThreadDemo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建MyCallable对象（表示多线程要执行的任务）
        MyCallable myCallable = new MyCallable();
        //创建FutureTask对象（作用管理多线程运行的结果）
        FutureTask<Integer> ft = new FutureTask<>(myCallable);
        //创建Thread类的对象并启动（表示线程）
        Thread t1 = new Thread(ft);
        t1.start();
        Integer res = ft.get();
        System.out.println(res);
    }
}
 

2.4 三种实现方式对比
 

优点缺点
继承Thread类编程简单，可以直接使用Thread中的方法可拓展性差，不能再继承其他类
实现Runnable接口拓展性强，实现该接口同时还可以继承其他类编程相对复杂，不能直接使用Thread中的方法
实现Callable接口
 

3. 常见的成员方法
 

 

3.1 getName()和setName()
 

对于setName()来说，如果没有给线程设置名称，也是有默认的名字的，格式：Thread - X(x序号从0开始)
 

 

根据Thread类的空参构造可以看出，在创建对象时的默认名称格式
 

那怎么在自定义类中创建对象时就传入对象名称进行构造呢？
 

在多线程第一种实现方式中，自定义的类继承了Thread类，但是构造方法并没有继承，所以还需要在自定义类中手动的去实现构造方法
 

 

3.2 currentThread()和sleep()
 

currentThread可以获取当前线程的对象
 

当JVM虚拟机启动之后，会自动开启多条线程，其中一条线程就叫做main线程，作用就是调用main方法，并执行里面的代码
 

 

sleep()是让线程休眠指定的时间，单位是毫秒，哪条线程执行到这个方法，那么哪条线程就会休眠，时间到了之后会继续执行下面的操作
 

这里的异常可以直接抛出
 

 
 

再来看MyThread类，这里的异常处理不能使用Throw抛出了，因为父类Thread没有抛出，这里只能使用try-catch处理异常  
 

 

3.3 getPriority()和setPriority()
 

3.3.1 CUP的调度方式
 

CUP的调度方式是有两种的：分为抢占性调度和非抢占性调度
 

抢占式调度是一种允许高优先级线程中断低优先级线程的执行，从而立即获得CPU资源的调度方式。在这种模式下，操作系统会定期检查线程的优先级，并根据需要切换线程的执行， 对线程的访问是随机的
 

非抢占式调度是一种允许线程独占CPU直到其主动放弃或执行完毕的调度方式。在这种模式下，线程的执行时间由线程本身控制，调度器不会中断正在执行的线程，轮流执行线程
 

3.3.2 优先级
 

来看Thread类中优先级的设置，最小为1，最大为10，默认是5，优先级越高抢占到CUP的概率越高，只是说概率高，并不是优先级高的就肯定比优先级低的要先抢占到CUP
 

 
 

public class ThreadTest2 {
    public static void main(String[] args) {
        //创建线程要执行参数的对象
        MyRunable myRunable = new MyRunable();
        //创建线程对象
        Thread thread1 = new Thread(myRunable,"线程一");
        Thread thread2 = new Thread(myRunable,"线程二");

        //获取线程优先级
        System.out.println(thread1.getPriority());
        thread2.setPriority(10);
        System.out.println(thread2.getPriority());

        System.out.println(Thread.currentThread().getPriority());
    }
}
 

3.4 setDaemon()
 

设置为守护线程也类似于备胎线程，当其他线程执行完毕之后，守护线程会陆续结束（并不是立即结束）
 

 

public class ThreadTest3 {
    public static void main(String[] args) {
        MyThread1 thread1 = new MyThread1();
        MyThread2 thread2 = new MyThread2();
        thread1.setName("女神");
        thread2.setName("备胎");
        //把第二个线程设置为守护线程
        thread2.setDaemon(true);
        thread1.start();
        thread2.start();
    }
}
 

 
 
应用场景：例如在聊天软件中，当打开聊天窗口之后，开启聊天窗口的线程和发送文件的线程，这时就可以把发送文件设置为守护线程，当聊天窗口关闭之后，守护线程也就没有存在的必要了  
 

 

 

4. 多线程的生命周期
 

多线程的生命周期是指一个线程从创建到消亡的整个过程。在这个过程中，线程会经历不同的状态。一般来说，线程的生命周期可以归纳为以下几个主要阶段：
 

 

1. 新建（New）
 

  •  
    状态描述：线程被创建但尚未启动。使用new关键字和Thread类或其子类创建一个线程对象后，该线程就处于新建状态。此时，线程仅在内存中被分配了空间，但还没有开始执行。
     
  •  
    注意：在操作系统层面，真正的线程还没有被创建，只有调用了start()方法后，线程才会被操作系统创建并进入下一个状态。
     
 

2. 就绪（Runnable）
 

  •  
    状态描述：线程已经启动，但尚未获得CPU执行权，处于等待CPU分配资源的阶段。调用线程的start()方法后，线程会进入就绪状态。此时，线程已经具备了运行条件，但还需要等待系统为其分配CPU资源。
     
  •  
    注意：就绪状态并不是执行状态，线程需要等待CPU的调度才能进入运行状态。
     
 

3. 运行（Running）
 

  •  
    状态描述：线程获得CPU资源并执行其run()方法中的代码。当就绪状态的线程被系统选中并获得CPU执行权时，它会进入运行状态。
     
  •  
    状态转变：运行状态的线程可以转变为阻塞状态、就绪状态和死亡状态。如果线程失去了CPU资源，它会从运行状态转变为就绪状态；如果线程执行了某些导致阻塞的操作（如调用sleep()、wait()方法或进行I/O操作），它会进入阻塞状态；如果线程的run()方法执行完毕或被强制终止，它会进入死亡状态。
     
 

4. 阻塞（Blocked）
 

  •  
    状态描述：线程因为某些原因（如等待I/O操作完成、等待获取同步锁等）而暂停执行。处于阻塞状态的线程不会占用CPU资源，直到阻塞的原因被消除后，线程才会重新进入就绪状态并等待CPU的调度。
     
  •  
    状态转变：阻塞状态的线程可以转变为就绪状态和死亡状态。当阻塞的原因被消除（如I/O操作完成、获取到同步锁等），线程会重新进入就绪状态；如果线程在等待过程中被强制终止（如调用stop()方法），它会进入死亡状态。
     
 

5. 死亡（Terminated/Dead）
 

  •  
    状态描述：线程的生命周期结束。当线程的run()方法执行完毕或被强制终止时，线程会进入死亡状态。此时，线程所占用的资源会被释放。
     
  •  
    注意：死亡的线程不能被再次启动。如果尝试在死亡的线程上调用start()方法，会抛出IllegalThreadStateException异常。
     
 

5. 线程安全问题
 

先来看一个现象： 
 

使用多线程实现三个窗口卖票的业务
 

 

这时就出现了一些小问题，售卖的票中有相同的票，也有超出范围的票，出现这个问题的原因就是线程执行时是有随机性的，当一个线程休眠时，其他的线程就可以抢到CPU了，休眠之后就又可以争夺CPU，此时如果一个线程刚好执行到target++，还没来得及打印，其他线程抢回了CPU，并且执行了target++，这时就可能出现以上的情况
 

解决办法：把操作共享数据的代码锁起来，锁默认打开，如果有现成进去之后，锁自动关闭，里面的代码全部执行完毕，线程出来，锁自动打开，这样就可以解决上述问题
 

5.1 同步代码块
 

同步代码块是通过关键字synchronized来实现的，括号中需要传入一个锁对象，可以是任意的，但必须是唯一的，通常会使用Thread.class作为锁对象，因为字节码文件对象是唯一的
 

synchronized (锁对象){
            
}

 

public class MyThread3 extends Thread {
    static int ticket = 0;
    @Override
    public void run() {
        while (true) {
            synchronized (Thread.class) {
                if (ticket < 100) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticket++;
                    System.out.println("正在卖第" + ticket + "张票");
                } else {
                    break;
                }
            }

        }
    }
}
 

要注意的是，synchronized在这里不能写在while循环外面，不然的话只有线程一就把循环的内容执行完了，然后剩余的线程由于target不满足循环条件，就不会再执行了  
 

5.2 同步方法
 

把synchronized加在方法上就是同步方法
 

格式：修饰符 synchronized 返回类型方法名（方法参数）{...}；
 

特点：同步方法是锁住方法里面所有的代码，锁对象不能自己指定，在非静态方法中，锁对象为this所指的对象，在static静态方法中，锁对象指的是当前类的字节码文件的对象
 

还是上面的例子，这次 实现 Runnable接口，使用同步方法试一下
 

public class MyRunnable implements Runnable {
    int ticket = 0;

    @Override
    public void run() {
        while (true) {
            if (func()) break;
        }
    }

    private synchronized boolean func() {
        if (ticket == 100) {
            return true;
        } else {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticket++;
            System.out.println(Thread.currentThread().getName() + "在卖第" + ticket + "张票");
        }
        return false;
    }
}
 

6. 锁
 

上面的同步代码块和同步方法虽然也是起到了把一段代码锁起来的效果，但是并没有直接看出哪里加上了锁，哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作
 

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

 
 
void lock() : 获得锁
 
 
void unlock() : 释放锁
 

 

Lock是一个接口，所以需要通过它的实现类ReentrantLock来实例化对象，然后再调用上面两个方法
 

以之前创建的MyThread3为例，由于需要创建三个MyThread3的对象，所以在MyThread3中创建的锁对象也会被创建三次，那么就会出现之前超出范围的问题，所以创建的锁对象要用static修饰一下
 

 

但这时会出现一个问题，程序最终并没有停止
 

 这是因为假如线程一抢到了CPU，并执行完毕之后跳出了循环，线程二和线程三还在锁的外面，所以需要改变释放锁的位置，可以利用 finally 来解决这个问题
 

public class MyThread3 extends Thread {
    static int ticket = 0;
    static Lock lock = new ReentrantLock();

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

 

6.1 死锁
 

它指的是两个或多个线程在执行过程中，由于竞争资源而造成的一种阻塞现象，若无外力作用，这些线程都将无法向前推进，死锁通常发生在两个或多个线程相互等待对方释放锁的情况，一般就是在锁的嵌套中容易发生，所以要避免这种写法
 

7. 等待唤醒机制
 

void wait()当前线程等待，直到被其他线程唤醒
void notify()随机唤醒单个线程
void notifyAll()唤醒所有线程
 

等待（wait）：当一个线程执行到某个对象的wait()方法时，它会释放当前持有的锁（如果有的话），并进入等待状态。此时，线程不再参与CPU的调度，直到其他线程调用同一对象的notify()或notifyAll()方法将其唤醒。
 

唤醒（notify/notifyAll）:
 

 
 
notify: 唤醒在该对象监视器上等待的某个线程，如果有多个线程在等待，那么具体唤醒哪一个是随机的
 
 
notifyAll: 唤醒在该对象监视器上等待的所有线程
 
 
调用wait方法的线程会释放其持有的锁，被唤醒的线程在执行之前，必须重新获取被释放的锁
 

 

 

public class Cook extends Thread {
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    if (Desk.foodFlag == 0) {
                        try {
                            Desk.lock.wait();//厨师等待
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        Desk.count--;
                        System.out.println("还能再吃" + Desk.count + "碗");
                        Desk.lock.notifyAll();//唤醒所有线程
                        Desk.foodFlag = 0;
                    }
                }
            }
        }
    }
}
 

 

public class Foodie extends Thread {
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    if (Desk.foodFlag == 1) {
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println("已经做好了");
                        Desk.foodFlag = 1;
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}
 

public class Desk {
    public static int foodFlag = 0;

    public static int count = 10;
    //锁对象
    public static Object lock = new Object();
}
 

这里实现的功能就是，厨师做好事务放在桌子上，美食家开始品尝，如果桌子上没有食物，美食家就等待，有的话，厨师进行等待
 

7.1 阻塞队列
 

在Java中，阻塞队列（BlockingQueue）是java.util.concurrent包下的一个接口，它支持两个附加操作的队列。这两个附加的操作是：在元素从队列中取出时，如果队列为空，则等待直到队列中有元素可取；在元素添加到队列时，如果队列已满，则等待直到队列中有空间可用。阻塞队列主要用于生产者-消费者场景，其中生产者线程用于向队列中添加元素，而消费者线程从队列中取出元素。
 

 

  •  
    生产者-消费者场景：在多线程环境下，生产者线程向队列中添加元素，消费者线程从队列中取出元素。阻塞队列能够平衡生产者和消费者的处理能力。
     
  •  
    任务队列：在异步处理框架中，将待处理的任务放入阻塞队列中，由线程池中的线程去取任务并执行。
     
 

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

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

    @Override
    public void run() {
        while (true){
            try {
                queue.put("美食");
                System.out.println("已经做好了一道美食");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 

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

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

    @Override
    public void run() {
        while (true){
            try {
                String food = queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
 

public class ThreadTest6 {
    public static void main(String[] args) {
        //必须指定阻塞队列的上限
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);
        Cook1 cook1 = new Cook1(queue);
        Foodie1 foodie1 = new Foodie1(queue);
        cook1.start();
        foodie1.start();
    }
}
 

在Cook1和Foodie1两个类中，发现并没有去使用同步代码块或是锁，因为take()和put()这两个方法在底层已经使用到了锁，如果再使用锁就会发生死锁
 

 

此外，由于锁是在方法内部使用的，所以方法外面的打印语句由于CPU抢占的原因，可能发生之前重复打印的情况
 

 

8. 多线程的六种状态
 

多线程的六种状态分别为：新创建，可运行，被阻塞，等待，计时等待，被终止
 

 

在Java中是没有定义运行状态的，因为当线程抢夺到CPU的执行权之后，接下来就该交给操作系统了，也没有必要再定义了
 

9. 线程池
 

9.1 线程池的概念和使用
 

在之前我们写的代码中，用到线程就创建，用完之后线程就消失了，这样会浪费操作系统的资源，也存在一些弊端，通过线程池就可以解决这个问题
 

线程池是一种线程使用模式，它维护着多个线程，等待着监督管理者分配可并发执行的任务
 

线程池的核心原理：
 

 
 
  1.  
    创建一个空的线程池
     
  2.  
    提交任务时，线程会创建新的线程对象，任务分配完毕，线程归还给线程池，下次再提交任务时，不需要创建新的线程，直接复用已有的线程即可
     
  3.  
    如果提交任务时，线程池中没有空闲线程，也无法创建新的线程，任务就会排队等待
     
 

 

public static ExecutorService newCachedThreadPoll()创建一个没有上限的线程池
public static ExecutorService newCachedThreadPoll(int nThread)创建有上限的线程池
 

先来正常的获取线程池对象，提交任务，销毁线程
 

 

public class ThreadTest7 {
    public static void main(String[] args) throws InterruptedException {
        //获取线程池对象
        ExecutorService pool1 = Executors.newCachedThreadPool();
        //提交任务
        pool1.submit(new MyRunable());
        //销毁线程池
        pool1.shutdown();
    }
}
 

线程复用：
 

线程池中的线程是复用的，一旦一个线程完成了它的任务，他就会回到线程池中等待下一个任务，如果任务提交的速度不快，或者线程池的配置较小，那么就可能看到同一个线程被用来执行多个任务
 

 

例如上面的代码中，每次提交任务，如果线程池中有空闲的线程，就会复用，而不是创建新的线程
 

9.2 自定义线程池
 

通过上面介绍的静态方法创建出来的线程池不够灵活，如果说等待的线程过多，阻塞队列中已经排满了线程，这时修改起来就不好操作，使用自定义线程池可以对所有现成进行同一管理和监控，便于及时发现问题，并及时进行配置和调整
 

创建自定义线程池用到的参数：核心线程的数量，线程池中最大线程池的数量，空闲时间（值），空闲时间（单位），阻塞队列，创建线程的方式，要执行的任务过多时的解决方案
 

解释：核心线程就是指一直存在于线程池中的线程，两个空闲时间就是值，创建出来的临时线程空闲的时间，超过这个时间就意味着这靠核心线程就足以完成当前提交的任务，就需要销毁临时线程，节约资源，要执行的任务过多时的解决方案指的是，当前线程池中线程的数量已经达到了最大，并且阻塞队列也已经排满了，就需要把多出来的任务踢出去
 

 
 
不断地提交任务，会有以下三个临界点：
 
 
1. 当核心线程满了之后，再提交任务就会排队
 
 
2. 当核心线程和阻塞队列都满了之后，就会创建临时线程
 
 
3. 当核心线程，阻塞队列，临时线程都满了之后，会触发任务的拒绝策略
 

 

任务拒绝策略：默认使用丢弃任务并抛出RejectedExecutionException异常
 

 

public class MyThreadPoolDemo1 {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                3,//核心线程数量，不能小于0
                6,//最大线程数，不能小于0，大于等于核心线程数
                60,//最大存活时间
                TimeUnit.SECONDS,//单位，用TimeUnit指定
                new ArrayBlockingQueue<>(3),//阻塞队列
                Executors.defaultThreadFactory(),//创建线程工厂
                new ThreadPoolExecutor.AbortPolicy()//AbortPolicy是ThreadPoolExecutor的静态内部类
        );
    }
}
 

最大并行数是指计算机系统或软件在处理任务时能够同时执行的最大指令或数据数量。
 

 
 
线程池多大合适：
 
 
CPU密集型运算：计算比较多，采用最大线程数 + 1
 
 
I/O密集型运算：如果读取本地文件或读取数据库的操作比较多
 

 

 

在这里插入图片描述

                

        

        

        

    




    

      

        

            

              
                
                  2的n次方_
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    39
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    20
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  6
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
【web】java多线程（吐血万字超详解）

				
			

			

				

					爱干饭的猿的博客
				

				

					09-14
					
					1375
					
				

			

		

		

			
				
本文是多线程初级入门，主要介绍了线程、Thread类及常用方法、线程状态、JVM区域划分、线程安全、synchronized 锁、JUC下的Lock 锁、volatile 关键字、wait 和 notify 用法。

			
		

	



                

              
                



	

		

			

				
					
Java 线程安全万字详解 ，面试随便问！

				
			

			

				

					
				

				

					04-19
					
					775
					
				

			

		

		

			
				
Java 线程安全万字详解 ，面试随便问！

			
		

	



                


  
              

                


	

		

			

				
					
Java 多线程 万字最详解

				
			

			

				

					weixin_44062380的博客
				

				

					05-05
					
					627
					
				

			

		

		

			
				
文章目录Java多线程多线程概述线程与进程线程调度同步与异步并发与并行线程阻塞Java 多线程的实现继承 Thread 类实现 Runnable 接口实现 `Callable`接口Thread 类讲解线程状态`currentThread()`线程休眠`sleep()`线程中断`interrupt()`守护线程`setDaemon()`主线程之前完成`join()`线程安全问题线程不安全的演示解决方法 1：同步代码块解决方法 2：同步方法解决方法 3：显示锁 Lock更多 synchronized 用法显示锁

			
		

	





	

		

			

				
					
万字详解-JAVA线程池分析实战与利弊详解

				
			

			

				

					胖虎儿的博客
				

				

					05-30
					
					4671
					
				

			

		

		

			
				
万字详解-JAVA线程池分析实战与利弊详解，讲解线程池参数意义，执行流程，线程池利弊，以及分析了tomcat激进线程池的实现原理

			
		

	



		

			
		



	

		

			

				
					
Java进阶线程

				
			

			

				

					hlizoo的博客
				

				

					08-05
					
					87
					
				

			

		

		

			
				
万字详解带你进一步理解常见的锁策略、死锁、Synchronized 原理、CAS、JUC(java.util.concurrent) 的常见类


			
		

	





	

		

			

				
					
Java面试复习体系总结（2021版,持续更新）

					
热门推荐

				
			

			

				

					Viper的程序员修炼手册
				

				

					02-26
					
					11万+
					
				

			

		

		

			
				
Java面试复习体系总结（2021版）
一、Java基础




内容




Java基础（一）：Java集合框架（超详细解析，看完面试不再怕）


Java基础（二）：迭代器（Iterator）（含使用方法详解）


Java基础 （三）：LinkedList（含使用方法详解）


Java基础（四）：ArrayList（含使用方法详解）


Java基础（五）：HashSet（使用方法详解）


Java基础（六）：HashMap（使用方法详解）


Java基础（七）：栈 Stack（使用方法详解）

			
		

	





	

		

			

				
					
java架构师进阶之路

				
			

			

				

					henhenha的博客
				

				

					03-30
					
					3410
					
				

			

		

		

			
				
包含了计算机基础、算法和数据结构、常用工具、java核心知识、性能优化、基础框架、数据库、消息队列、缓存中间件、搜索引擎、大数据、RPC、网关、容器、面试等知识

			
		

	





	

		

			

				
					
Java 面试全解析：核心知识点与典型面试题

				
			

			

				

					m0_67394002的博客
				

				

					07-30
					
					406
					
				

			

		

		

			
				
老王资深面试官，阿里云社区认证专家。十余年编程从业经验，现上市公司技术研发经理，曾就职于360，有着丰富的大型系统设计、开发和调优的经验，在不断探索和学习的过程中，积累了宝贵的编程与面试经验。公众号「Java中文社群」。Java诞生于1991年，Java的前身叫做Oak（橡树），但在注册商标的时候，发现这个名字已经被人注册了，后来团队的人就在咖啡馆讨论这件事该怎么办，有人灵机一动说叫Java如何，因为当时他们正在喝着一款叫做Java的咖啡。注版本发布时间。...

			
		

	





	

		

			

				
					
Java基础（6）- Java代码笔记3

				
			

			

				

					weixin_47062560的博客
				

				

					08-30
					
					595
					
				

			

		

		

			
				
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。

			
		

	





	

		

			

				
					
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？

				
			

			

				

					Loewen丶的小窝
				

				

					08-26
					
					8262
					
				

			

		

		

			
				
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。

			
		

	





	

		

			

				
					
操作系统原子操作

				
			

			

				

					zzt_is_me的博客
				

				

					08-28
					
					5520
					
				

			

		

		

			
				
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。

			
		

	





	

		

			

				
					
基于Java+Springboot+Vue+elememt宠物用品商城系统设计实现

					
最新发布

				
			

			

				

					央顺科技官方博客
				

				

					08-31
					
					815
					
				

			

		

		

			
				
随着信息技术的不断发展，我们现在已经步入了信息化的时代了，而信息时代的代表便是网络技术的日渐成熟，而现在网络已经和我们的生活紧密的联系起来了，我们不敢想象没有网络我们的生活会像怎么样，也许就像食物中没有调料现在的生活离开了网络会变得索然无味。通过网络我们可以足不出户的做许多事情，例如工作、娱乐、学习，交友和购物等等许多我们数之不尽的事情，而就是因为网络我们的生活变得多姿多彩，或许有时甚至帮我们省下不少的时间和给予了我们更多的机遇。宠物网上商城对我们来说就有这些意义。

			
		

	





	

		

			

				
					
死锁及其产生条件

				
			

			

				

					秋夫人
				

				

					08-26
					
					2525
					
				

			

		

		

			
				
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。

			
		

	





	

		

			

				
					
优秀的开源项目

				
			

			

				

					猪猪
				

				

					08-28
					
					535
					
				

			

		

		

			
				
目录热key多线程并行秒级百G级日志工具ES操作工具消息推送平台HTTP 客户端业务层的分布式限流组件企业级微服务解决方案hotkey: 京东App后台中间件，毫秒级探测热点数据，毫秒级推送至服务器集群内存，大幅降低热key对数据层查询压力asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各线程的执行顺序，带全链路执行结果回调。多线程编排一站式解决方案。来自于京东主App后台。asyncTool: 解决任意的多线程并行、串行、阻塞、依赖、回调的并行框架，可以任意组合各

			
		

	





	

		

			

				
					
输入三个正整数，找出不大不小的值

				
			

			

				

					laocooon的博客
				

				

					08-30
					
					508
					
				

			

		

		

			
				
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。

			
		

	





	

		

			

				
					
spring-data-redis中RedisRepository仓储

				
			

			

				

					OceanSky的专栏
				

				

					08-27
					
					444
					
				

			

		

		

			
				
Id@RedisHash注解的value属性和@Id注解指定键值的命名空间，组合成user:id；@RedisHash的属性timeToLive属性指定键值的超时时间。CrudRepository接口中默认定义实现了save、saveAll、findById、existsById、findAll、findAllById、count、deleteById、delete、deleteAllById、deleteAll等方法，基本满足了对redis操作的需求；如果有特殊需求可以自定义实现。

			
		

	





	

		

			

				
					
JVM 内存参数

				
			

			

				

					iOS逆向与安全
				

				

					08-29
					
					1468
					
				

			

		

		

			
				
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。

			
		

	





	

		

			

				
					
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner

				
			

			

				

					qq_32590535的博客
				

				

					08-28
					
					474
					
				

			

		

		

			
				
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 6

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值