19. 线程的生命周期、同步机制、懒汉式线程安全的实现、死锁、线程的通信、线程的另外两种创建方式、集合框架的概述

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量99 收藏 3
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alilili_alilili/article/details/115277353
版权

1. 线程的生命周期

在这里插入图片描述

public enum State {
    /**
     * Thread state for a thread which has not yet started.
     */
    NEW,

    /**
     * Thread state for a runnable thread.  A thread in the runnable
     * state is executing in the Java virtual machine but it may
     * be waiting for other resources from the operating system
     * such as processor.
     */
    RUNNABLE,

    /**
     * Thread state for a thread blocked waiting for a monitor lock.
     * A thread in the blocked state is waiting for a monitor lock
     * to enter a synchronized block/method or
     * reenter a synchronized block/method after calling
     * {@link Object#wait() Object.wait}.
     */
    BLOCKED,

    /**
     * Thread state for a waiting thread.
     * A thread is in the waiting state due to calling one of the
     * following methods:
     * <ul>
     *   <li>{@link Object#wait() Object.wait} with no timeout</li>
     *   <li>{@link #join() Thread.join} with no timeout</li>
     *   <li>{@link LockSupport#park() LockSupport.park}</li>
     * </ul>
     *
     * <p>A thread in the waiting state is waiting for another thread to
     * perform a particular action.
     *
     * For example, a thread that has called <tt>Object.wait()</tt>
     * on an object is waiting for another thread to call
     * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
     * that object. A thread that has called <tt>Thread.join()</tt>
     * is waiting for a specified thread to terminate.
     */
    WAITING,

    /**
     * Thread state for a waiting thread with a specified waiting time.
     * A thread is in the timed waiting state due to calling one of
     * the following methods with a specified positive waiting time:
     * <ul>
     *   <li>{@link #sleep Thread.sleep}</li>
     *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
     *   <li>{@link #join(long) Thread.join} with timeout</li>
     *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
     *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
     * </ul>
     */
    TIMED_WAITING,

    /**
     * Thread state for a terminated thread.
     * The thread has completed execution.
     */
    TERMINATED;
}

2. 线程的同步机制

  • 知识概述
/**
 * 例题：开启三个窗口售票，总票数为100张。
 * <p>
 * 使用继承Thread类的方式实现
 *
 * 1. 程序执行中出现了重票、错票
 * 2. 如何解决？需要一个线程针对于ticket完全操作结束之后，其他的线程才能进入继续操作ticket
 *
 * 3. 代码层面如何解决？线程的同步机制。
 *
 * 4. 同步机制的实现方式：
 *  方式一：同步代码块
 *      synchronized(同步监视器){
 *          //需要被同步的代码
 *      }
 *     说明：① 需要被同步的代码，即为操作共享数据的代码
 *           ② 共享数据？ 多个线程共同操作的数据
 *           ③ 同步监视器，即为一个对象。俗称：锁
 *             要求：① 任何一个类的对象都可以充当同步监视器。
 *                  ② 多个线程必须共享同一个同步监视器。
 *
 *
 *  方式二：同步方法
 *       如果操作共享数据的代码完整的声明在一个或多个方法中，此时可以考虑将此方法声明为同步方法。
 *
 *       对于非静态的同步方法而言，默认的同步监视器是：this
 *       对于静态的同步方法而言，默认的同步监视器是：当前类.class
 *
 *
 * 测试使用同步代码块解决继承Thread类的方式中的线程安全问题。
 *
 *  小结：针对同步监视器：实现Runnable的方式中可以考虑使用this。在继承Thread类的方式时，慎重this。
 *                      可以考虑使用的同步监视器是：当前类.class
 *        针对于操作共享数据的代码：不能“包”少了，也不能“包”多了
 *
 *  5. 同步机制：好处：解决了线程的安全问题。
 *              缺点：执行同步代码块的过程中，其实是单线程的。效率低。
 */

2.1 同步代码块解决继承Thread中的线程安全问题

class Window extends Thread {

    static int ticket = 100;//初始票数100张
    static Object obj = new Object();
    @Override
    public void run() {
            while (true) {

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

//            synchronized(obj){
            synchronized(Window.class){ //Class clazz = Window.class

            //不能使用this
//            synchronized(this){  //此时的this代表w1,w2,w3
                if (ticket > 0) {

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "卖票，当前票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {

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

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

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

    }
}

2.2 同步代码块解决实现Runnable中的线程安全问题

class Window1 implements Runnable{
    int ticket = 100;
//    Object obj = new Object();
//    Dog dog = new Dog();
    @Override
    public void run() {
        while(true){
            synchronized (this){ //此时的this表示w，是唯一的
//            synchronized (dog){

                if(ticket > 0){
                    try {
                        Thread.sleep(30);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖票，当前票号为：" + ticket);
                    ticket--;

                }else{
                    break;
                }
            }

        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

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

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

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

class Dog{

}

2.3 同步方法解决继承Thread中的线程安全问题

class Window2 implements Runnable {
    int ticket = 100;

    @Override
    public void run() {
        while (true) {
//            synchronized (this){
                show();
//            }
        }
    }

    public synchronized void show() { //默认的同步监视器是this，此题中代表：w
        if (ticket > 0) {
            try {
                Thread.sleep(30);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "卖票，当前票号为：" + ticket);
            ticket--;

        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w = new Window2();

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

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

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

2.4 同步方法解决实现Runnable中的线程安全问题

class Window3 extends Thread {

    static int ticket = 100;//初始票数100张

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

            show();

        }

    }

    public static synchronized void show(){ //此时的同步监视器是：this。此题中表示：t1,t2,t3
        if (ticket > 0) {

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "卖票，当前票号为：" + ticket);
            ticket--;
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {

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

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

        t1.start();
        t2.start();
        t3.start();
    }
}
  • 练习
    在这里插入图片描述

3. 单例模式：懒汉式的线程安全的实现

public class SingletonTest1 {
    public static void main(String[] args) {
        Runtime r1 = Runtime.getInstance();
        Runtime r2 = Runtime.getInstance();

        System.out.println(r1 == r2);
    }
}

//懒汉式
class Runtime {
    //1. 私有化类的构造器
    private Runtime() {

    }

    //2. 声明当前类的一个变量
    private static Runtime instance = null;

    //3. 调用方法，返回当前类的一个实例
    //方式1：
//    public static synchronized Runtime getInstance(){
//
//        if(instance == null){
//
//            instance = new Runtime();
//        }
//        return instance;
//    }
    //方式2：比方式1好
//    public static Runtime getInstance() {
//
//        synchronized (Runtime.class) {
//            if (instance == null) {
//
//                instance = new Runtime();
//            }
//        }
//        return instance;
//    }

    //方式3：推荐
    public static Runtime getInstance() {

        if(instance == null){

            synchronized (Runtime.class) {
                if (instance == null) {

                    instance = new Runtime();
                }
            }
        }
        return instance;
    }
}

4. 死锁

/**
 * 死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
 *
 * 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
 *
 */

public class DeadLockTest {

    public static void main(String[] args) {

        StringBuilder s1 = new StringBuilder();
        StringBuilder s2 = new StringBuilder();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1){

                    s1.append("a");
                    s2.append("1");

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);
                    }

                }

            }
        }.start();

        new Thread(new Runnable(){

            @Override
            public void run() {
                synchronized (s2){

                    s1.append("c");
                    s2.append("3");

                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }

                }
            }
        }).start();
    }
}

5. 线程的通信

/**
 * 例题：使用两个线程打印 1-100。线程1, 线程2 交替打印
 *
 * 线程的通信：
 *
 * wait():一旦执行此方法，就会使得执行此方法所在的线程进行阻塞状态。同时释放同步监视器。
 * notify():一旦执行此方法，就会唤醒被wait()的线程中优先级最高的那个线程。在获得同步监视器的情况下，
 *         继续执行被wait()之后的代码。
 * notifyAll():一旦执行此方法，就会唤醒所有被wait()的线程。在获得同步监视器的情况下，继续执行被wait()之后的代码。
 *
 *
 * 说明：1. wait()/ notify() / notifyAll() :必须使用在同步代码块或同步方法中。
 *      2. wait()/ notify() / notifyAll()的调用者必须是同步代码块或同步方法中的同步监视器。
 *         否则，会报：IllegalMonitorStateException
 *      3. wait()/ notify() / notifyAll() 是定义在java.lang.Object中。
 *
 *
 * 高频面试题：sleep() 和  wait()的异同？
 *      1. 两个方法声明的位置？Thread:sleep()   / Object:wait()
 *      2. 使用的范围有没有要求？ sleep():在任何想使用的地方。  wait():必须使用在同步代码块或同步方法中
 *      3. 如果都放在同步代码块或同步方法中，是否释放锁？ sleep():不会  wait():会
 *      4. 都会导致线程进入阻塞状态。但是结束阻塞状态的方式不同？ sleep():时间到就结束阻塞。  wait():需要被唤醒
 *
 */

class PrintNumber implements Runnable{
    int number = 1;
    Object obj = new Object();

    @Override
    public void run() {

        while(true){
            synchronized (obj) {
                //唤醒被wait()的线程
                obj.notify();
                if(number <= 100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;
                }else{
                    break;
                }
                //当前的线程进入阻塞
                try {
                    obj.wait(); //会释放同步监视器
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //。。。。
            }
        }
    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        PrintNumber num = new PrintNumber();

        Thread t1 = new Thread(num);
        Thread t2 = new Thread(num);

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

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

面试题：sleep() 和 wait()的异同

  • 生产者消费者题目
/**
 * 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，
 * 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，
 * 店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，
 * 店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
 *
 *
 * 分析：
 * 1. 是不是多线程问题？是  生产者线程、消费者线程
 * 2. 会出现线程安全问题吗？会。有共享数据
 * 3. 共享数据是什么？ 产品的数量
 * 4. 是否存在线程的通信？ 有！
 *
 */
public class ProducterConsumerTest {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Producter p1 = new Producter(clerk);
        Consumer c1 = new Consumer(clerk);
        Consumer c2 = new Consumer(clerk);

        p1.setName("生产者1");
        c1.setName("消费者1");
        c2.setName("消费者2");

        p1.start();
        c1.start();
        c2.start();
    }
}

class Clerk{//店员
    int productNum;//产品数据

    //添加产品
    public synchronized void addProduct(){
        if(productNum < 20){
            productNum++;
            System.out.println(Thread.currentThread().getName() + "生产了第" + productNum + "个产品");

            notifyAll();

        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //减少产品
    public synchronized void consumeProduct(){
        if(productNum > 0){
            System.out.println(Thread.currentThread().getName() + "消费了第" + productNum + "个产品");
            productNum--;

            notifyAll();

        }else{
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Producter extends Thread{ //生产者

    Clerk clerk;

    public Producter(Clerk clerk){
        this.clerk = clerk;
    }

    @Override
    public void run() { //生产产品

        System.out.println(Thread.currentThread().getName() + "开始生产产品");

        while(true){

            try {
                Thread.sleep(25);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.addProduct();

        }
    }
}

class Consumer extends Thread{ //消费者
    Clerk clerk;

    public Consumer(Clerk clerk){
        this.clerk = clerk;
    }
    @Override
    public void run() { //消费产品
        System.out.println(Thread.currentThread().getName() + "开始消费产品");
        while(true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumeProduct();
        }
    }
}

6. 了解：线程的另外的2种创建方式

6.1 实现Callable接口

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

/*创建多线程的方式三：实现Callable （jdk5.0新增的）
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable<Integer>{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
  
        
//      接收返回值
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Integer sum = (Integer) futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

面试题：使用Runnable和Callable的对比？
1.结论：实现Callable的方式好
2.体现：
① 可以在call方法中抛出异常，更灵活
② call方法，相较于run()可以有返回值
③ 可以通过泛型的方法，指定返回值的确定类型。

6.2 使用线程池

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

//创建并使用多线程的第四种方法：使用线程池
//使用线程池创建多线程的好处：
//1.降低了资源的消耗，使用完的线程可以被复用。
//2.提高了程序的响应速度。
//3.便于管理。

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//        //设置线程池的属性
//        System.out.println(service.getClass());//ThreadPoolExecutor
        service1.setMaximumPoolSize(20);


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

7. 了解：Lock的方式解决线程安全问题

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
   int ticket = 100;
   private final ReentrantLock lock = new ReentrantLock();
   public void run(){
      
      while(true){
         try{
            lock.lock();
            if(ticket > 0){
               try {
                  Thread.sleep(10);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
               System.out.println(ticket--);
            }else{
               break;
            }
         }finally{
            lock.unlock();
         }
      }
   }
}

public class ThreadLock {
   public static void main(String[] args) {
      Window t = new Window();
      Thread t1 = new Thread(t);
      Thread t2 = new Thread(t);
      
      t1.start();
      t2.start();
   }
}

8. 集合框架的概述

  • 了解
数组在内存存储方面的特点：
数组初始化以后，长度就确定了。
数组声明的类型，就决定了进行元素初始化时的类型。

数组在存储数据方面的弊端：
数组初始化以后，长度就不可变了，不便于扩展
数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的个数
数组存储的数据是有序的、可以重复的。---->存储数据的特点单一


/* 二、集合框架
* java.util.Collection:存储一个一个的数据
*      |----java.util.List:存储有序的、可重复的数据。  ----> “动态”数组
*              |---- ArrayList\LinkedList\Vector
*      |----java.util.Set:存储无序的、不可重复的数据   ----> 高中学的"集合"
*              |---- HashSet \ LinkedHashSet \TreeSet
*
* java.util.Map:存储一对一对的数据 (key-value) ----> 高中学的"函数" y = f(x)   y = 2 * x + 1 (x1,y1),(x2,y2)
*      |---- HashMap\LinkedHashMap\TreeMap\Hashtable\Properties
*
* 三、三个层面（递进关系）
* 层次一：掌握不同接口的主要实现类的实例化，及常用方法 （ArrayList\HashSet\HashMap）
* 层次二：掌握不同实现类之间的区别
* 层次三：常用的集合类的底层实现原理--->数据结构。 （ArrayList\LinkedList\HashMap）
*/
alilili_alilili
关注
Java多线程-多线程知识点总结和企业真题
02-04
- **题3**：Java中创建线程的两种方式是什么？ - 继承`Thread`类和实现`Runnable`接口。 2. **如何实现多线程** - **题1**：给出一个例子展示如何使用`Thread`类创建线程。 - 创建`Thread`子类，重写`run()`...
【逢考必问】Java线程池七个参数详解
happydecai的博客
09-17 545
java多线程开发时，常常用到线程池技术，这篇文章是对创建java线程池时的七个参数的详细解释。 从源码中可以看出，线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。下面会对这7个参数一一解释。 一、corePoolSize 线程池核心线程大小 线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会 被销毁，除非设置了allowCoreTh
线程池 线程安全的单例模式 饿汉方式 懒汉方式
黑桃K
05-05 729
线程池： 第一个线程安全任务队列+提前创建好最大数据上限的工作线程； 针对大量数据请求处理的场景； 好处： 1.避免大量线程频繁创建与销毁带来的时间成本； 2.任务节点以及线程有上限，避免资源耗尽的风险； 核心线程将需要处理的数据，以及数据处理的方法组织成一个任务，放入线程池，线程池只需要取出一个任务节点，通过其中的方法处理节点中的数据； ThreadTask{要处理的数据，数据处理的方法} ThreadPool{创建线程，创建线程安全的任务队列} typedef void(*handler_t)(int
java创建通信线程,3.0Java高级编程【懒汉式线程安全，线程通信的常用方法，新增创建线程的方式】...
weixin_39531378的博客
03-21 59
懒汉式线程安全，线程通信的常用方法，新增创建线程的方式1.单例模式中懒汉式线程安全的写法class Bank{private Bank(){}private static Bank instance;//效率稍差/*public synchronized static Bank getBankInstance(){if (instance == null){instance = new Bank(...
创建线程四种方法详解；及说明ThreadPoolExecutor方式创建线程池
qq_42263473的博客
04-09 3805
一：继承Thread类的方式 #创建一个线程 class MyThred extends Thread{ public MyThred(String name) { super(name); } @Override public void run() { // 线程内的操作 for(int i=0;i<10;i++){ System.out.println(Thread.currentThread().
7-05Thread-Runnable-Callable-懒汉-饿汉
ruanwangmingbo的博客
07-05 138
多线程 对象关键字：volatile 并发编程Thread 用继承实现 记得看看，查查面试资料题 1. 并行：每个人用自己的东西，不影响 2. 并发：两个人同时用一个东西，时间相同； 3. 进程：独立程序 4. 线程：单个进程内的并发； 5. 线程和io流都是工具； 6. Thread是唯一代表线程的； 7. 要想体现并发特性，必须调用start启动线程； 方法 开始 Thread.start(); 睡眠，就是阻塞状态 Thread.sleep(); 直到当前线程执行完毕 Thread.jo
多线程单例模式并发访问
10-19
总结起来，多线程环境下的单例模式实现需要注意线程安全问题，尤其是懒汉式单例，需要采取适当的同步措施来防止多线程环境下的实例化问题。此外，对于不同场景的需求，可以选择不同的实现方式来优化性能和资源使用。
多线程、JVM复习&面试&强化训练100题
03-27
线程池是JDK提供的一个用于管理线程生命周期的框架，它能够有效控制线程数量，减少资源消耗。Executor框架包括了Executor、ExecutorService、CompletionService、Future、Callable等接口和类。Executors则是Executor...
Java多线程编程深入详解
03-28
- 讨论了在多线程环境下，如何安全地实现单例模式，包括饿汉式和懒汉式两种模式。 7. 死锁的成因和避免 - 详细解释了死锁的概念，通过示例演示了死锁的产生条件，并给出了避免死锁的策略。 8. 线程的优先级与...
Java学习路线：day19
01-20
多线程线程的生命周期线程的同步同步代码块处理实现Runnable的线程安全问题同步代码块处理继承Thread类的线程安全问题同步方法处理实现Runnable的线程安全问题同步方法处理继承Thread类的线程安全问题线程安全的单例...
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 852
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 434
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 537
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1271
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 795
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 333
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1111
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 884
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 328
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
Java多线程：懒汉式单例线程安全解决方案
- 饿汉式在类加载时就立即创建了单例对象，由于类加载是线程安全的，因此这种实现方式不存在线程安全问题。 - 实现方式通常如上述代码所示，通过静态初始化块或枚举类型保证实例化只发生一次。 2. **懒汉式** ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值