Java之 多线程

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量140 收藏
点赞数
分类专栏： Java核心类库 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49528561/article/details/119359978
版权

Java之多线程

1. 线程与进程

概念：

  1. 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。
  2. 线程：
  • 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程最少有一个线程。
  • 线程实际上是在进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。
  • 每个线程都拥有自己的栈空间，共用一份堆内存。

线程调度：

  1. 分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
  2. 抢占式调度：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
    CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻， 只能执行一个线程，而 CPU在多个线程间切换速度相对我们的感觉要快，看上去就是 在同一时 刻运行。 其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的 使 用率更高。

2. 同步与异步&并发与并行

同步： 排队执行,效率低但是安全。
异步： 同时执行,效率高但是数据不安全。
并发： 指两个或多个事件在同一个时间段内发生。
并行： 指两个或多个事件在同一时刻发生（同时发生）

3. 类继承Thread（创建线程）（第一种线程方式）

概念： 继承Thread的类可以实现多线程。在类中重写run()方法，run()方法中的代码就是另一条线程，在主方法调用start()方法才会执行类中的run()。
格式：

public static void main(String[] args){
    MyThread m = new MyThread;
    m.start();
}
class MyThread extends Thread{
    //这里的代码，就是一条新的执行路径。
    //这个代码的触发方式不是调用run()，而是通过Thread对象的strat()来启动任务
    @Override
    public void run(){
    }
}

4. 实现Runnable（创建任务）（第二种线程方式）

概念： 实现Runnable接口的类可以编写线程的任务，任务对象传给线程构造方法能够用线程实现任务。
格式：

/**
 * 多线程技术
 */
public static void main(String[] args){
    //实现Runnable
    //1.    创建一个任务对象
    MyRunnable r = new MyRunnable();
    //2.    创建一个线程，并为其分配一个任务
    Thread t = new Thread(r);
    //3.    执行这个线程
    t.start();
}

/**
 * 用于给线程执行的任务
 */
class MyRunnable implements Runnable{
    @Override
    public void run(){
        //编写线程的任务
    }
}

5. 实现Runnable 与 继承Thread相比的优势：

  1. 通过创建任务，然后给线程分配的方式来实现的多线程，更适合多个线程同时执行相同任务的情况。
  2. 可以避免单继承所带来的局限性。
  3. 任务与线程本身是分离的，提高了程序的健壮性。
  4. 线程池技术，接收Runnable类型的任务，不接收Thread类型的线程。

6. Thread类

字段：

变量和类型字段描述
static intMAX_PRIORITY线程可以拥有的最大优先级。
static intMIN_PRIORITY线程可以拥有的最低优先级。
static intNORM_PRIORITY分配给线程的默认优先级。

常用构造方法：

构造器描述
Thread()分配新的 Thread对象。
Thread(Runnable target)分配新的 Thread对象。
Thread(Runnable target, String name)分配新的 Thread对象。 并为其起名称，可以使用getName()方法获取。
Thread(String name)分配新的 Thread对象。

常用方法：

变量和类型方法描述
static ThreadcurrentThread()返回对当前正在执行的线程对象的引用。
longgetId()返回此Thread的标识符。
StringgetName()返回此线程的名称。
intgetPriority()返回此线程的优先级。
voidsetName(String name)将此线程的名称更改为等于参数 name 。
voidsetPriority(int newPriority)更改此线程的优先级。
voidsetDaemon(boolean on)将此线程标记为 daemon线程（守护线程）或用户线程。（在start()之前设置）
static voidsleep(long millis)导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。
static voidsleep(long millis, int nanos)导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数加上指定的纳秒数，具体取决于系统定时器和调度程序的精度和准确性。
voidinterrupt()中断此线程。（为线程打上标记可以被catch捕获）

注意： 程序中main()为主线程，其中开启的线程为子线程，当主线程死亡时，如果子线程还没死亡，那么子线程会继续执行直到自我死亡，即死亡由自己决定，统称为用户线程。守护线程则是指当进程中所有用户线程死亡时，所有守护线程也会自动死亡，无论自我死亡与否。
eg:

/**
 * 获取主线程名称和子线程名称
 */
public static void main(String[] args){
    //获取主线程名称
    System.out.println(Thread.currentThread().getName());
    new Thread(new MyRunnable());
}
static class MyRunnable implements Runnable{
    @Override
    public void run(){
        //获取子线程名称
        System.out.println(Thread.currentThread().getName());
    }
}

7. 线程休眠sleep

eg:

/**
 * 线程休眠
 */
public static void main(String[] args) throws InterruptedException {
    //线程每次休眠时间1秒
    for (int i = 0; i < 10; i++) {
        System.out.println(i);
        Thread.sleep(1000);
    }
}

8. 线程阻塞

概念： 也称为耗时操作。是指所有比较消耗时间的操作，比如常见的文件读取操作，接收输入操作等。

9. 线程的中断

一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定。
eg:

/**
 * 线程中断
 */
public static void main(String[] args) throws InterruptedException {
    //主线程结束则杀死子线程
    Thread t = new Thread(new MyRunnable());
    t.start();
    for (int i = 0; i < 5; i++) {
        System.out.println(i);
        Thread.sleep(1000);
    }
    t.interrupt();  //为子线程打上可以被catch的标记
}
static class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                return; //杀死线程
            }
        }
    }
}

10. 守护线程setDaemon()

eg:

/**
 * 守护线程
 */
public static void main(String[] args) throws InterruptedException {
    //用户线程死亡，守护线程自动死亡
    Thread t = new Thread(new MyRunnable());
    t.setDaemon(true);  //将t设置为守护线程
    t.start();
    for (int i = 0; i < 5; i++) {
        System.out.println(i);
        Thread.sleep(1000);
    }
}
static class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
    }
}

11. 线程安全问题

概念： 多线程异步执行可能会出现线程不安全的问题。

解决方法（均为不公平锁）：

  1. 隐式锁：
    • 同步代码块
    • 同步方法
  2. 显式锁
    • Lock

eg： 结果可能会出现符负数的原因是因为，假设三个线程为A，B，C，当count=1的时候，A进入while()，但是由于线程阻塞，还没到count–操作时，B和C也进入了while()，所以导致A执行了count–后count等于0时，B和C线程仍然会执行while()。

/**
 * 线程不安全情况
 */
public static void main(String[] args){
    Runnable run = new Count();
    //三个线程执行同个任务
    new Thread(run).start();
    new Thread(run).start();
    new Thread(run).start();
}
static class Count implements Runnable{
    private int count = 10;
    @Override
    public void run() {
        while (count>0){    //不允许出现负数
            count--;
            System.out.println(count);  //结果可能会出现负数
        }
    }
}

12. 线程安全1-同步代码块

概念： 被Synchronized锁住的代码快称为同步代码块，当一个线程执行进入同步代码块时，锁对象会变为上锁状态，其他线程会询问锁对象状态，等到在同步代码块中的线程执行出去时，锁对象才会变为解锁状态，此时其他线程一旦询问锁对象为开锁状态，就会进行抢占进入同步代码块，从而实现同步运行。
注意： Java中所有对象都可以作为锁对象。实现同步要确保所有线程询问的是同一个锁对象！
格式：

Synchronized(锁对象){
	//同步代码块
}

eg：

/**
 * 线程安全情况1：同步代码块
 */
public static void main(String[] args){
    Runnable run = new Count();
    //三个线程执行同个任务
    new Thread(run).start();
    new Thread(run).start();
    new Thread(run).start();
}
static class Count implements Runnable{
    private int count = 10;
    private Object o = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (o){   //锁位置
                if (count>0){   //不允许出现负数
                    count--;
                    System.out.println(count);  //结果不会出现负数
                }else {break;}
            }
        }
    }
}

13. 线程安全2-同步方法

概念： 即用Synchronized修饰方法。此时锁对象为this。如果是静态方法，即用static修饰的方法，此时锁对象为类名.class，即类的字节码。
eg：

/**
 * 线程安全情况2：同步方法
 */
public static void main(String[] args){
    Runnable run = new Count();
    //三个线程执行同个任务
    new Thread(run).start();
    new Thread(run).start();
    new Thread(run).start();
}
static class Count implements Runnable{
    private int count = 10;
    @Override
    public void run() {
        while (true){
            //如果有线程执行下面这个代码块时deCount()也不会被线程执行，因为用的是同一把锁
            synchronized (this){}
            if (!deCount()){break;}
        }
    }
    //同步方法
    public synchronized boolean deCount(){
        //锁对象为this
        //如果是static修饰的方法锁对象为Count.class
        if (count>0){
            count--;
            System.out.println(count);
            return true;
        }
        return false;
    }
}

14. 线程安全3-显示锁Lock 子类 ReentrantLock

概念： 可以自己标记锁和开锁位置。
常用方法：

  1. 锁住：lock()
  2. 开锁：unlock()

eg：

/**
 * 线程安全情况3：隐式锁Lock
 */
public static void main(String[] args){
    Runnable run = new Count();
    //三个线程执行同个任务
    new Thread(run).start();
    new Thread(run).start();
    new Thread(run).start();
}
static class Count implements Runnable{
    private int count = 10;
    //创建锁对象l
    private Lock l = new ReentrantLock();
    @Override
    public void run() {
        while (count>0){
            l.lock();   //锁住
            if (count>0){
                count--;
                System.out.println(count);
            }else {break;}
            l.unlock(); //开锁
        }
    }
}

15. 公平锁与非公平锁

概念：

  1. 公平锁：比如A线程先到锁前等待，等锁解开就是A线程先执行。
  2. 非公平锁：无论哪个线程先等待，等锁解开后所有线程一起抢占。

注意： 三个线程安全解决方案均为非公平锁
公平锁实现方法： 创建显式锁Lock时指定为true（默认为false）。
公平锁创建格式： ReentrantLock(true)

16. 线程死锁

概念： 线程A在锁AA中，线程B在锁BB中，A在等待BB开锁进入BB，而B在等待AA开锁进入AA。
避免线程死锁产生： 在任何有可能导致锁产生的方法里不要再调用其他方法让其他锁产生。
eg：

/**
 * 线程死锁
 */
public static void main(String[] args){
    A a = new A();
    B b = new B();
    //子线程要b调用bOut()。可是现在主线程b还在调用say()，等待a调用aOut()
    new MyThread(a, b).start();
    //主线程要a调用aOut。可是现在子线程a还在调用say()，等待b调用bOut()
    b.say(a);
}
static class MyThread extends Thread{
    private A a;
    private B b;
    MyThread(A a, B b){
        this.a = a;
        this.b = b;
    }
    @Override
    public void run() {
        a.say(b);
    }
}
static class A{
    public synchronized void say(B b){
        System.out.println("A：你从BB出来我就从AA出来");
        b.bOut();
    }
    public synchronized void aOut(){
        System.out.println("A从AA出来进入BB");
    }
}
static class B{
    public synchronized void say(A a){
        System.out.println("B：你从AA出来我就从BB出来");
        a.aOut();
    }
    public synchronized void bOut(){
        System.out.println("B从BB出来进入AA");
    }
}

17. 多线程通信问题：生产者与消费者

概念： 使用等待和唤醒的方法让多线程进行交互合作。实现A生产时B休眠，B消费时A休眠的循环。
Object类常用方法：

变量和类型方法描述
voidnotify()随机唤醒正在此对象监视器上等待的单个线程。
voidnotifyAll()唤醒等待此对象监视器的所有线程。
voidwait()导致当前线程等待它被唤醒，通常是 通知或 中断。
voidwait(long timeoutMillis)导致当前线程等待它被唤醒，通常是 通知或 中断，或者直到经过一定量的实时。
voidwait(long timeoutMillis, int nanos)导致当前线程等待它被唤醒，通常是 通知或 中断，或者直到经过一定量的实时。

eg：

/**
 * 多线程通信问题：生产者与消费者
 * 唤醒A，休眠B，A生产--休眠A，唤醒B，B消费
 */
public static void main(String[] args){
    Product p = new Product();
    new Producer(p).start();
    new Consumer(p).start();
}
//生产者按规律生产10种产品
static class Producer extends Thread{
    private Product p;
    public Producer(Product p) {
        this.p = p;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if (i%2==0){
                p.setNameAndPrice("中华香烟", "46");
            }else {
                p.setNameAndPrice("利群香烟", "17");
            }
        }
    }
}
//消费者按生产者生产顺序买走产品
static class Consumer extends Thread{
    private Product p;
    public Consumer(Product p) {
        this.p = p;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            p.buy();
        }
    }
}
//产品类
static class Product{
    private String name;
    private String price;
    private boolean flag = true;
    //生产者生产商品
    public void setNameAndPrice(String name, String price) {
        if (flag){
            this.name = name;
            this.price = price;
            flag = false;
            this.notifyAll();
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    //消费者买走商品
    public void buy(){
        if (!flag){
            System.out.println("消费者买走的产品名称："+name+"，价格："+price);
            flag = true;
            this.notifyAll();
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

18. 线程的六种状态

  1. New： 尚未启动的线程处于此状态。（新生、就绪）
  2. Runnable： 在Java虚拟机中执行的线程处于此状态。（运行）
  3. Blocked： 被阻塞等待监视器锁定的线程处于此状态。（阻塞）
  4. Waiting： 无限期等待另一个线程执行特定操作的线程处于此状态。（锁定）
  5. Timed Waiting： 正在等待另一个线程执行最多指定等待时间的操作的线程处于此状态。（等待）
  6. Terminated： 已退出的线程处于此状态。（死亡）

19. 实现Callable接口（创建带返回值的线程）（第三种线程方式）

概念： 主线程指派给子线程任务，然后给主线程返回结果，这期间主线程可以进行等待。
接口格式：

public interface Callable<V> {
	V call() throws Exception;
}

Callable获取返回值： Callalble接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执 行，如果不调用不会阻塞。
使用格式：

//1. 编写类实现Callable接口 , 实现call方法
class XXX implements Callable<T> {
    @Override
    public <T> call() throws Exception {
        return T;
    }
}
//2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
FutureTask<Integer> future = new FutureTask<>(callable);
//3. 通过Thread,启动线程
new Thread(future).start()

FutureTask常用方法：

变量和类型方法描述
protected booleancancel(boolean x)传入true则表示取消该线程。返回值为true表示线程还未执行完毕，成功取消；返回值为false表示线程已经执行完毕，取消失败。
Vget()如果需要等待计算完成，然后检索其结果。（主线程会等待子线程执行完返回结果再执行）
Vget(long timeout,TimeUnit unit)如果需要，最多等待计算完成的给定时间，然后检索其结果（如果可用）。
protected voidisDone()判断该子线程是否执行完毕。

20. Runnable与Callable

相同点：

  • 都是接口
  • 都可以编写多线程程序
  • 都采用Thread.start()启动线程

不同点：

  • Runnable没有返回值；Callable可以返回执行结果
  • Callable接口的call()允许抛出异常；Runnable的run()不能抛出

21. 线程池ExecutorService

线程池的概念： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。
线程池的好处：

  • 降低资源消耗。
  • 提高响应速度。
  • 提高线程的可管理性。

Java中四种线程池：

  1. 缓存线程池
  2. 定长线程池
  3. 单线程池
  4. 周期定长线程池

前三个线程池对象获取格式均为： ExecutorService service =… …;
向线程池中加入并执行新的任务： Service.execute(new Runnable(){…});

22. 缓存线程池

长度无限制
创建线程对象格式： ExecutorService service = Executors.newCachedThreadPool();

执行流程：

  1. 判断线程池是否存在空闲线程
  2. 存在则使用
  3. 不存在,则创建线程并放入线程池，然后使用

23. 定长线程池

长度是指定的数值
创建线程对象格式(创建时指定线程池长度nThread)： ExecutorService service = Executors.newFixedThreadPool(int nThreads);
执行流程：

  1. 判断线程池是否存在空闲线程
  2. 存在则使用
  3. 不存在空闲线程，且线程池未满的情况下，则创建线程并放入线程池，然后使用
  4. 不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程

24. 单线程线程池

长度为1，排队执行
创建线程对象格式： ExecutorService service = Executors.newSingleThreadExecutor();
执行流程：

  1. 判断线程池的那个线程是否空闲
  2. 空闲则使用
  3. 不空闲，则等待池中的单个线程空闲后使用

25. 周期定长线程池

周期任务 长度指定
执行流程：

  1. 判断线程池是否存在空闲线程
  2. 存在则使用
  3. 不存在空闲线程，且线程池未满的情况下，则创建线程并放入线程池，然后使用
  4. 不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程

创建线程对象格式：ScheduledExecutorService service = Executors.newScheduledThreadPool (int nThread);
周期性任务执行时：
定时执行，当某个时机触发时，自动执行某任务

定时执行仅一次格式： service.schedule(new Runnable(){},num2,num3);

  1. 参数1：runnable类型的任务
  2. 参数2：时长数字
  3. 参数3：时长数字的单位，TimeUnit.SECONDS表示秒

周期执行格式： service.scheduleAtFixedRate(new Runnable(){},num2,num3,num4);

  1. 参数1：runnable类型的任务
  2. 参数2：时长数字(延迟执行的时长，即第一次执行等待的时间)
  3. 参数3：周期时长(每次执行的间隔时间)
  4. 参数4：时长数字的单位，TimeUnit.SECONDS表示秒

eg：

//五秒后每间隔一秒执行一次
ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
service.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
},5,1, TimeUnit.SECONDS);

26. Lambda表达式

概念： 函数式编程思想。将方法省略至只有参数和方法体。
格式： (方法参数) –> {方法体}
eg：

public static void main(String[] args) {
    //使用Lambda表达式后
    print((int x,int y) -> {
        return x+y;
        },100,200);
    //使用前
    print(new MyMath() {
        @Override
        public int sum(int x, int y) {
            return x+y;
        }
    },100,200);
}
//定义方法实现接口
public static void print(MyMath m,int x,int y){
    int num = m.sum(x,y);
    System.out.println(num);
}
//定义一个接口
static  interface MyMath{
    int sum(int x,int y);
}
Boo_lean
关注
专栏目录
JAVA之多线程
maxu0808的博客
03-18 3751
一、什么是多线程 1. 线程与进程、并行与并发 进程：每个进程拥有自己的一整套变量。一个进程可以包含多个线程。 线程：线程属于进程，多个线程会存在共享数据的情况发生，也就是多个线程会共享同一块内存区域。 一个例子：打开word是一个进程，打开qq音乐又是另外一个进程，两进程之间不会互相影响（都有自己的一块内存区域）。但比如在qq音乐里一遍听歌，一遍又浏览排行榜，那就是在qq音乐这个进程里又有两个线程，它们之间会存在共享内存的情况。 并发：多线程就是并发的例子，一块CPU调度时会分为好多个时间片，每
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5709
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java之多线程创建
legendaryhaha的博客
03-20 3693
Java多线程归纳前言传统的线程创建继承Thread类实现Runnable接口两者的共同点两者差别JDK 1.5开始出现的线程创建 前言 进程是资源分配的最小单位，而线程是执行任务的最小的单位。进程里的线程可以共享该进程拥有的资源，而进程之间不可以，进程奔溃了，在保护模式下，不会影响其他进程，而线程一旦出问题了，该进程也要GG思密达。总而言之，创建一个线程比创建一个进程要省事得多儿，这也是当今为...
【Java多线程】停止线程
一定要站在自己热爱的生活里闪闪发光
10-03 5万+
目录 1. 停止线程的方法 2. 判断线程是否是停止状态 3. 能停止的线程——异常法 4. 在沉睡中停止 5. 能停止的线程——暴力停止 6. 方法stop()与java,lang.ThreadDeath异常 7. 使用return停止线程 1. 停止线程的方法 在Java中有以下3种方法可以终止正在进行的线程： 1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2）使用stop方法强行终止线程，但是不推荐使用这个方法，因为stop和suspend及resum
编程必备：JAVA多线程详解
拾一二的博客
06-14 8571
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
java多线程编程实例
热门推荐
延陵缥缈的博客
05-25 8万+
        这篇文章主要介绍了java多线程编程实例，分享了几则多线程的实例代码，具有一定参考价值，加深多线程编程的理解还是很有帮助的，需要的朋友可以参考下。1.相关知识：Java多线程程序设计到的知识：（1）对同一个数量进行操作（2）对同一个对象进行操作（3）回调方法使用（4）线程同步，死锁问题（5）线程通信等等2．示例2.1三个售票窗口同时出售20张票程序分析：    (1)票数要使用同一...
JAVA多线程之线程同步
qq_39367410的博客
10-09 3082
线程同步、并发的基本概念以及解决问题的三种方法
Java 多线程编程基础(详细)
一夜星尘
11-03 3万+
Java多线程编程基础进程与线程多线程实现Thread类实现多线程Runnable接口实现多线程Callable接口实现多线程多线程运行状态多线程常用操作方法线程的命名和获取线程休眠线程中断线程强制执行线程让步线程优先级设定线程的同步和锁死线程同步处理线程死锁 进程与线程 进程与线程的基本认识 进程（Process）：进程是程序的一次动态执行过程，它经历了从代码加载、执行、到执行完毕的一个完整过程；同时也是并发执行的程序在执行过程中分配和管理资源的基本单位，竞争计算机系统资源的基本单位。 线程（Thread
Java之线程安全
qq_64580912的博客
05-10 5688
线程1获取到锁之后执行了对应的代码,线程2也要执行这个方法,但是检查锁的状态已经被持有,所以它处在堵塞(BLOCK)的状态,当线程1执行完方法之后,线程2才有可能获得到锁(并不一定),因为线程是抢占式执行的,可能线程1再次执行这个方法,再次先获得到了锁.现在举一个形象点的例子,小人1去上厕所,它获取到了锁,进入到上厕所,其他的小人要想上厕所,因为现在已经上了锁,所以他们只能处在等待堵塞的状态,当小人1出来之后,他们又在一起竞争(小人1也参与竞争),竞争到锁的就可以先上厕所,其它的小人又需要等待,
Java多线程与并发
lydms的博客
06-21 1万+
假设线程A已经拥有了某个对象（不是类）的锁，而其它线程B、C想要调用这个对象的某个 synchronized方法（或者块），由于B、C线程在进入对象的 synchronized方法（或者块）之前必须先获得该对象锁的拥有权，而恰巧该对象的锁目前正被线程A所占用，此时B、C线程就会被阻塞，进入一个地方去等待锁的释放，这个地方便是该对象的锁池。假设线程A调用了某个对象的wat（）方法，线程A就会释放该对象的锁，同时线程A就进入到了该对象的等待池中，进入到等待池中的线程不会去竞争该对象的锁。
JAVA之多线程（基础图）
02-20
JAVA之多线程（基础图）
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
java向多线程中传递参数的三种方法详细介绍
09-05
以下将详细介绍三种向Java多线程传递参数的方法。 1. **通过构造方法传递数据** 当创建Thread类或其子类的实例时，可以利用构造方法来传递数据。这些数据通常存储为类的成员变量，在`run()`方法中使用。例如： ``...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
工厂模式的介绍及实现
户伟伟的博客
09-25 96
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 175
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 824
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
智能BI平台项目
2302_79400545的博客
09-22 223
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 498
Android的系统结构的设计混合了分层设计和分块设计。
Java多线程机制详解
"Java的多线程机制章节主要讲解了Java如何实现并控制多线程，包括线程的概念、特点以及在Java中的实现方式。Java的多线程机制以面向对象的方式提供，使得学习和使用变得简单易懂。" 在Java编程中，多线程机制是实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值