Java多线程编程核心技术（笔记）4-Lock的使用

最新推荐文章于 2024-06-04 23:11:16 发布
最新推荐文章于 2024-06-04 23:11:16 发布
阅读量162 收藏
点赞数
分类专栏： java多线程 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38171871/article/details/108121900
版权

Lock的使用

4.1 使用ReentrantLock类

4.1.1 使用ReentrantLock实现同步：测试1

4.1.2 使用ReentrantLock实现同步：测试2

package org.test.t8.t_1;

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

public class MyService {

	private Lock lock = new ReentrantLock();
	
	public void methodA() {
		try {
			lock.lock();
			System.out.println("methodA begin ThreadName="  
			        + Thread.currentThread().getName() + " time=" + 
					System.currentTimeMillis());
			Thread.sleep(5000);
			System.out.println("methodA end ThreadName=" 
			        + Thread.currentThread().getName() + " time=" + 
					System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public void methodB() {
		try {
			lock.lock();
			System.out.println("methodB begin ThreadName="  
			        + Thread.currentThread().getName() + " time=" + 
					System.currentTimeMillis());
			Thread.sleep(5000);
			System.out.println("methodB end ThreadName="  
			        + Thread.currentThread().getName() + " time=" + 
					System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	
	public static void main(String[] args) throws InterruptedException{
		
		MyService service = new MyService();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();
		ThreadAA aa = new ThreadAA(service);
		aa.setName("AA");
		aa.start();
		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();
		ThreadBB bb = new ThreadBB(service);
		bb.setName("BB");
		bb.start();
		
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
调用lock.lock()的线程就持有了对象监视器，其他线程只有等待锁被释放时再次争抢。
效果和使用synchronized一样，线程之间还是按照顺序执行的。

4.1.3 使用Condition实现等待/通知：错误用法与解决

使用ReentrantLock结合Condition类是可以实现前面介绍过的“选择性通知”。

package other.thread15;

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


public class DemoService {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    
    public void await() {
        try {
            lock.lock();
            System.out.println("await时间为：" + System.currentTimeMillis());
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public void signal() {
        try {
            lock.lock();
            System.out.println("signal时间为：" + System.currentTimeMillis());
            condition.signal();
        }finally {
            lock.unlock();
        }
    }
}

package other.thread15;

public class ThreadA extends Thread {

    private DemoService service;
    
    public ThreadA(DemoService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.await();
    }
}

package other.thread15;

public class Test {

    public static void main(String[] args) throws InterruptedException {
        DemoService service = new DemoService();
        ThreadA threadA = new ThreadA(service);
        threadA.start();
        Thread.sleep(1000);
        service.signal();
    }

}

在condition.await()方法调用之前需要调用lock.lock()获得同步监视器。

4.1.4 正确使用Condition实现等待/通知

Object类中的wait()相当于Condition类中的await()方法。
Object类中的wait（long timeout）相当于Condtion类中的await（long time，TimeUnit unit）方法。
Object类中的notify()方法相当于Condition类中的signal()方法。
Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。

4.1.5 使用多个Condition实现通知部分线程：错误用法

signalAll()会唤醒所有线程

4.1.6 使用多个Condition实现通知部分线程：正确用法

package other.thread15;

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


public class DemoService {
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    
    public void awaitA() {
        try {
            lock.lock();
            System.out.println("await A 时间为：" + System.currentTimeMillis());
            conditionA.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public void awaitB() {
        try {
            lock.lock();
            System.out.println("await B 时间为：" + System.currentTimeMillis());
            conditionB.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public void signalA() {
        try {
            lock.lock();
            System.out.println("signal A 时间为：" + System.currentTimeMillis());
            conditionA.signalAll();
        }finally {
            lock.unlock();
        }
    }
    
    public void signalB() {
        try {
            lock.lock();
            System.out.println("signal B 时间为：" + System.currentTimeMillis());
            conditionB.signalAll();
        }finally {
            lock.unlock();
        }
    }
}


package other.thread15;

public class ThreadA extends Thread {

    private DemoService service;
    
    public ThreadA(DemoService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.awaitA();
    }
}

package other.thread15;

public class ThreadB extends Thread {

    private DemoService service;
    
    public ThreadB(DemoService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        service.awaitB();
    }
}

package other.thread15;

public class Test {

    public static void main(String[] args) throws InterruptedException {
        DemoService service = new DemoService();
        ThreadA threadA = new ThreadA(service);
        threadA.start();
        ThreadB threadB = new ThreadB(service);
        threadB.start();
        Thread.sleep(1000);
        service.signalA();
    }

}

在这里插入图片描述

4.1.7 实现生产者/消费者模式：一对一交替打印

public class MyService {  
    private ReentrantLock lock= new ReentrantLock();  
    private Condition condition = lock.newCondition();  
    private boolean hasValue = false;  

    public void set() {  
        try{  
            lock.lock();  
            while (hasValue == true) {  
                condition.await();  
            }  
            System.out.println("----");  
            hasValue = true;  
            condition.signal();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } finally {  
            lock.unlock();  
        }  
    }  

    public void get() {  
        try {  
            lock.lock();  
            while (hasValue == false) {  
                condition.await();  
            }  
            System.out.println("****");  
            hasValue = false;  
            condition.signal();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } finally {  
            lock.unlock();  
        }  
    }  
}  
//两个线程
public class MyThread1 extends Thread {  
    private MyService service;  
    public MyThread1(MyService service) {  
        this.service = service;  
    }  
    @Override  
    public void run() {  
        for (int i=0; i<100; i++) {  
            service.set();  
        }  
    }  
}  

public class MyThread2 extends Thread{  
    private MyService service;  
    public MyThread2(MyService service) {  
        this.service = service;  
    }  
    @Override  
    public void run() {  
        for (int i=0; i<100; i++) {  
            service.get();  
        }  
    }  
} 

public class Run {  
    public static void main(String[] args) throws InterruptedException {  
        MyService service = new MyService();  
        MyThread1 a = new MyThread1(service);  
        a.start();  

        MyThread2 b = new MyThread2(service);  
        b.start();  

    }  
}

4.1.8 实现生产者/消费者模式：多对多交替打印

出现假死，用signalAll()解决。

4.1.9 公平锁与非公平锁

  • 公平锁
package demo;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {
    private ReentrantLock lock;

    public MyService(boolean isFair) {
        super();
        lock = new ReentrantLock(isFair); // FIXME:判断公平锁非公平锁的传入参数
    }

    public void serviceMethod(){
        try{
            lock.lock();
            System.out.println("获得线程锁的名称：" + Thread.currentThread().getName());
        }finally {
            lock.unlock();
        }
    }
}

package demo;
import com.sun.tools.internal.ws.wsdl.document.soap.SOAPUse;

public class Run1 {
    public static void main(String[] args) {
        final MyService myService = new MyService(true); // FIXME: 公平锁

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("开始运行的线程名称：" + Thread.currentThread().getName());
                myService.serviceMethod();
            }
        };
        Thread[] threadArray = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threadArray[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threadArray[i].start();
        }
    }
}
  • 非公平锁
package demo;
import com.sun.tools.internal.ws.wsdl.document.soap.SOAPUse;

public class Run1 {
    public static void main(String[] args) {
        final MyService myService = new MyService(false); // FIXME: 公平锁

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("开始运行的线程名称：" + Thread.currentThread().getName());
                myService.serviceMethod();
            }
        };
        Thread[] threadArray = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threadArray[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threadArray[i].start();
        }
    }
}

4.1.10 方法getHoldCount()、getQueueLength()、getWaitQueueLength()的测试

  • 方法int getHoldCount()的作用是查询当前线程保持此锁定的个数，也就是调用lock()方法的次数。
  • 方法int getQueueLength()的作用是返回正等待获取此锁锁定的线程估计数，比如有5个线程，1个线程首先执行await()方法，那么在调用getQueueLength()方法后返回值是4，说明有4个线程同时在等待lock的释放。
  • 方法int getWaitQueueLength(Condition condition) 的作用是返回等待与此锁定相关的给定条件Condition的线程估计数，比如有5个线程，每个线程都执行了同一个condition对象的await()方法，则调用getWaitQueueLength(Conditioncondition)方法时返回的int值是5。

4.1.11 方法hasQueuedThread()、hasQueuedThreads()、hasWaiters()的测试

  • lock.hasQueuedThread(Thread A)：指定的线程是否正在等待获取此锁定；
  • lock.hasQueuedThreads()：查询是否有线程正在等待获取锁；
  • lock.hasWaiters(Condition cond)：查询是否有线程在cond.await状态中;

4.1.12 方法isFair()、isHeldByCurrentThread()、isLocked()的测试

  • isFair()：作用是判断ReentrantLock是否是公平锁。返回true为公平锁，false为非公平锁。
  • isHeldByCurrentThread()：查询当前线程是否保持此锁定。
  • isLocked()：查询此锁是否由任意线程保持。

4.1.13 方法lockInterruptibly()、tryLock()、tryLock(long timeout,TimeUnit unit)的测试

  • lockInterruptibly()：如果当前线程未被中断，则获取锁定(需要等待别的线程释放锁才行)，如果已被中断则出现异常。但是使用lock.lock()时，当前线程被中断，不会报错。
  • tryLock()：仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定，否则就不获取。就是说只会去获取未被锁定的线程。
  • tryLock(long timeout,TimeUnit unit)：如果给定线程在等待时间内未被另一个线程保持，且当前线程未被中断，则获取该锁定，否则就不获取，相当于tryLock()加了等待时间。

4.1.14 方法awaitUninterrptibly()的使用

线程在调用condition.await()后处于await状态，此时调用thread.interrupt()会报错
但是使用condition.awaitUninterruptibly()后，调用thread.interrupt()则不会报错

4.1.15 方法awaitUntil()的使用

此方法可以证明线程在等待时间达到前，可以被其他线程提前唤醒。

public class Service {

	private ReentrantLock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	public void waitMethod() {
		try {
			Calendar calendarRef = Calendar.getInstance();
			calendarRef.add(Calendar.SECOND, 3);
			lock.lock();
			System.out.println("wait begin timer=" + System.currentTimeMillis());
			condition.awaitUntil(calendarRef.getTime());
			System.out.println("wait end timer=" + System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			lock.unlock();
		}
	}
	public void notifyMethod() {
		try {
			Calendar calendarRef = Calendar.getInstance();
			calendarRef.add(Calendar.SECOND, 3);
			lock.lock();
			System.out.println("notify begin timer=" + System.currentTimeMillis());
			condition.signalAll();
			System.out.println("notify end timer=" + System.currentTimeMillis());
		}finally{
			lock.unlock();
		}
	}
	public static void main(String[] args) {
		Service service = new Service();
		MyThreadA myThreadA = new MyThreadA(service);
		myThreadA.start();
	}
}

4.1.16 使用Condition实现顺序执行

略

4.2 使用ReentrantReadWriteLock类

读写锁共有两个锁，一个是读相关的锁，也称作共享锁，另一个是与写操作相关的锁，也称作排他锁。同时规定如下：

  • 读锁与读锁之间不互斥
  • 写锁与写锁之间互斥
  • 读锁与写锁之间互斥

4.2.1 类ReentrantReadWriteLock的使用：读读共享

class MyService {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read() {
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + " 获得读锁 "
                    + System.currentTimeMillis());
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

}

class ThreadA extends Thread {

    private MyService myService;

    public ThreadA(MyService myService) {
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.read();
    }

}

class ThreadB extends Thread {

    private MyService myService;

    public ThreadB(MyService myService) {
        this.myService = myService;
    }

    @Override
    public void run() {
        myService.read();
    }

}

public class ReadAndRead {

    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("AAAA");
        threadA.start();

        Thread.sleep(2000);

        ThreadB threadB = new ThreadB(service);
        threadB.setName("BBBB");
        threadB.start();
    }

}

BBBB 获得读锁 1541404600765
AAAA 获得读锁 1541404600765

4.2.2 类ReentrantReadWriteLock的使用：写写互斥

class MyService2 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void write() {
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + " 获得写锁 "
                    + System.currentTimeMillis());
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + " 结束写锁 "
                    + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

}

class ThreadA2 extends Thread {

    private MyService2 service2;

    public ThreadA2(MyService2 service2) {
        this.service2 = service2;
    }

    @Override
    public void run() {
        service2.write();
    }

}

class ThreadB2 extends Thread {

    private MyService2 service2;

    public ThreadB2(MyService2 service2) {
        this.service2 = service2;
    }

    @Override
    public void run() {
        service2.write();
    }
}

public class WriteAndWrite {

    public static void main(String[] args) {
        MyService2 service2 = new MyService2();
        ThreadA2 threadA2 = new ThreadA2(service2);
        threadA2.setName("AAA");
        ThreadB2 threadB2 = new ThreadB2(service2);
        threadB2.setName("BBB");

        threadA2.start();
        threadB2.start();
    }

}

AAA 获得写锁 1541405542280
AAA 结束写锁 1541405552281
BBB 获得写锁 1541405552282
BBB 结束写锁 1541405562282

4.2.3 类ReentrantReadWriteLock的使用：读写互斥

class MyService3 {

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read() {
        try {
            lock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + " 获得读锁 "
                    + System.currentTimeMillis());
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + " 结束读锁 "
                    + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write() {
        try {
            lock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + " 获得写锁 "
                    + System.currentTimeMillis());
            Thread.sleep(10000);
            System.out.println(Thread.currentThread().getName() + " 结束写锁 "
                    + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }

}

class ThreadA3 extends Thread {

    private MyService3 myService3;

    public ThreadA3(MyService3 myService3) {
        this.myService3 = myService3;
    }

    @Override
    public void run() {
        myService3.read();
    }

}

class ThreadB3 extends Thread {

    private MyService3 myService3;

    public ThreadB3(MyService3 myService3) {
        this.myService3 = myService3;
    }

    @Override
    public void run() {
        myService3.write();
    }
}

public class ReadAndWrite {

    public static void main(String[] args) {
        MyService3 service3 = new MyService3();
        ThreadA3 threadA3 = new ThreadA3(service3);
        threadA3.setName("AAA");
        ThreadB3 threadB3 = new ThreadB3(service3);
        threadB3.setName("BBB");

        threadA3.start();
        threadB3.start();
    }

}

AAA 获得读锁 1541407541955
AAA 结束读锁 1541407551955
BBB 获得写锁 1541407551955
BBB 结束写锁 1541407561955

4.2.4 类ReentrantReadWriteLock的使用：写读互斥

参考4.2.3

今天喝奶茶了吗？？
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lock4j--分布式锁中间件--使用实例
m0_67402013的博客
07-29 1082
说明本文用示例介绍分布式锁中间件lock4j的用法。相关网址httpshttps（Star数68）https友情提示本人实际使用lock4j过程中遇到了很多问题，不推荐使用lock4j，推荐直接使用redisson的分布式锁。获取锁超时时并没有抛异常，而是一直等待获取到锁lock4j与@Transactional类似将注解写在方法上，自动控制上锁与释放锁。lock4j支持Redis（RedisTemplate或Redisson）、Zookeeper作为底层。...
使用 @Lock 注解实现Spring JAP锁
热门推荐
Terry_Long的博客
01-09 1万+
JPA 2.0增加了6种新的锁模式，其中两个是乐观锁。JPA 2.0也允许悲观锁，并增加了3种悲观锁，第6种锁模式是无锁。  下面是新增的两个乐观锁模式：  1、OPTIMISTIC：它和READ锁模式相同，JPA 2.0仍然支持READ锁模式，但明确指出在新应用程序中推荐使用OPTIMISTIC。  2、OPTIMISTIC_FORCE_INCREMENT：它和WRITE锁模式
SpringBoot整合Lock4j
SeeYouAgain的博客
07-14 2390
Lock4j是一个分布式锁组件，其提供了多种不同的支持以满足不同性能和环境的需求。 简单易用，功能强大，扩展性强。支持redission,redisTemplate,zookeeper。可混用，支持扩展。
lock4j--分布式锁中间件--使用/实例
IT利刃出鞘的博客
06-28 6266
本文用示例介绍分布式锁中间件lock4j 的用法。
【Java多线程编程核心技术】4.Lock的使用-笔记总结
DChuan
11-22 406
相关链接： 【Java多线程编程核心技术】1.Java多线程技能-笔记总结 【Java多线程编程核心技术】2.对象及变量的并发访问（上）-笔记总结 【Java多线程编程核心技术】2.对象及变量的并发访问（下）-笔记总结 【Java多线程编程核心技术】3.线程间通信 -笔记总结 【Java多线程编程核心技术】4.Lock的使用-笔记总结 【Java多线程编程核心技术】5.定时器Timer...
《Java多线程编程核心技术》笔记
yinn
07-16 596
前言《Java多线程编程核心技术》这本书例子太多，基本占一半的篇幅都是例子代码，真正的干货比较少,记录几点新知识。synchronized和volatile关键词区别 关键词volatile是线程同步的轻量级实现，性能好，volatile只能修饰变量，而synchronized可以修饰方法以及代码块。 多线程访问volatile不会发生阻塞，而synchronized会出现阻塞； volatile能
《java 多线程编程核心技术》读书笔记六
不务正业的野猴子
08-27 300
ReentrantLock、ReentrantReadWriteLock ReentrantLock lock()、unlock()这两个方法之间的代码为线程同步执行 持有相同锁的方法均为同步执行 Condition await() 等同 Object中的wait() signal() 等同Object中的notify() signalAll() 等同Object中的notify...
《java多线程编程核心技术》核心笔记(三) Lock的使用
wangyan199366的博客
07-25 455
【Lock】 Lock lock = new ReentrantLock(); lock.lock()就是持有了对象监视器 其他线程只有等待锁的释放。 在使用notify()/notifyAll()方法进行通知时，被通知的线程是由JVM随机选择的，但是使用了 ReentrantLock结合Condition类是可以实现"选择性通知"的, 在Condition
Java多线程编程实战指南（核心篇）读书笔记（一）
冷血之心的博客
07-31 1万+
Java多线程编程实战指南（核心篇）读书笔记
《Java 多线程编程核心技术》学习笔记及总结
http://www.54tianzhisheng.cn/
06-05 1584
第一章 Java 多线程技能 进程和线程的概念及多线程的优点 使用多线程 继承 Thread 类 实现 Runnable 接口 currentThread 方法 isAlive 方法 sleep 方法 getId 方法 停止线程 判断线程是否是停止状态 在沉睡中停止 在停止中沉睡 能停止的线程 暴力停止 暂停线程 suspend 和 resume 方法的使用 yield 方法 线程的优先级 守护
《Java 多线程编程核心技术》-- 高洪岩著 阅读笔记
05-30
《Java 多线程编程核心技术》-- 高洪岩著 阅读笔记
Java多线程编程核心技术.zip
09-24
Java多线程编程核心技术和源码
JAVA多线程编程技术PDF
08-28
JAVA多线程编程技术PDF，是最经典的那个版本，多线程的所有知识点完爆读者
【JAVA多线程】多线程编程核心技术学习资料
03-02
【JAVA多线程】多线程编程核心技术学习资料。学习java多线程学习资料文档。适合初中级java开发人员学习的书籍资料
Java多线程编程核心技术_完整版_java_
09-30
详细介绍了java多线程的原理以及常用多线程编程方法及注意事项。
java环境部署
JiuMeilove的博客
06-04 406
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java中Overload和Override的区别
codedadi的博客
06-04 592
当调用Dog对象的makeSound方法时，将执行Dog类中的方法，而不是Animal类中的方法。定义：在子类中，有一个与父类同名、同参数列表、同返回类型（或协变返回类型）的方法，则称子类中的该方法为父类同名方法的重写。子类方法的访问权限不能低于父类方法的访问权限（如父类方法为public，则子类方法也必须是public）。Override（重写）：子类与父类之间，方法名、参数列表和返回类型（或协变返回类型）相同。定义：在同一个类中，方法名相同但参数列表（参数类型、参数数量或参数顺序）不同的多个方法。
JavaScript第九讲：BOM编程
最新发布
星途码客的博客
06-04 1439
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
Spring异步任务@Async的默认线程池执行器是如何初始化的
简放视野的专栏
06-03 647
Spring异步任务@Async的默认线程池执行器，是从哪里来？是如何初始化的？ 【结论】异步任务@Async的默认线程池执行器是通过TaskExecutionAutoConfiguration#applicationTaskExecutor自动注入的。
Java多线程编程-使用线程的缺点
05-26
4. 调试困难：多线程程序的调试比单线程程序复杂，因为多个线程之间的相互影响可能导致程序的错误行为。 5. 可靠性降低：线程之间的协作关系比较复杂，如果不正确地使用线程，可能会导致程序崩溃或者死锁等问题，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值