Java多线程及线程安全，时间片，锁，守护线程，定时器，wait，notify

已于 2022-10-12 20:44:06 修改
阅读量603 收藏 2
点赞数
分类专栏： Javase 文章标签： java jvm 开发语言
于 2022-08-05 16:02:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53881899/article/details/126177009
版权

目录

一、定义：

  • 进程是一个应用程序(软件)。
  • 线程是一个进程中的执行单元，一个进程有多个线程。
  • 例如：进程是公司，线程是公司中的员工。main方法线程，gc垃圾回收器线程。
  • 不同进程的内存独立，不共享。
  • 不同线程，堆内存和方法区内存共享，但栈内存不共享，一个线程独享一个栈，栈之间互不干扰，叫多线程并发。
  • 多线程是为了提高程序的处理效率。

二、实现线程的方法：

第一种：继承Thread类，重写run()方法，调用start()方法开启线程。
（1）start()方法的作用：在JVM中开辟一个新的栈空间，启动线程。启动的线程会在栈的底部自动调用run()方法。如果不用start而是用run，则不会开辟内存空间。
（2）代码：

public class Test{
    public static void main(String args[]){//main线程，主线程
        TestThread test=new TestThread();//创建线程对象
        test.start();//start方法开启线程
        for(int i=0;i<10;i++)
            System.out.println("主线程："+i);
    }
}
class TestThread extends Thread {
    public void run(){//run方法线程体
        for(int i=0;i<10;i++){
            System.out.println("分支线程："+i);
        }
    }
}
//可以看到主线程和run线程同时执行，而不是顺序执行

（3）执行结果：

在这里插入图片描述
（4）内存图：

在这里插入图片描述

第二种：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法。
（1）start()方法的作用：在JVM中开辟一个新的栈空间，启动线程。启动的线程会在栈的底部自动调用run()方法。如果不用start而是用run，则不会开辟内存空间。
（2）代码：

public class Test{
    public static void main(String args[]){//main线程，主线程
        TestThread test=new TestThread();//创建runnable接口实现类对象
        Thread thread = new Thread(test);//创建线程对象(代理)
        thread.start();//start方法开启线程
        for(int i=0;i<100;i++)
            System.out.println("主线程："+i);
    }
}
//可以看到主线程和run线程同时执行，而不是顺序执行
//runnable接口优点：所有线程可以共享一个类

class TestThread implements Runnable {
    public void run(){//run方法线程体
        for(int i=0;i<10;i++){
            System.out.println("分支线程："+i);
        }
    }
}
//可以看到主线程和run线程同时执行，而不是顺序执行

（3）运行结果：

在这里插入图片描述

三、线程生命周期：引入时间片概念

在这里插入图片描述

四、常用方法：

  1. 获取线程对象的名字：

线程对象.getName();

  1. 修改线程对象的名字：

线程对象.setName(name);

  1. 获取“当前”线程对象：

Thread t = Thread.currentThread();

是一个静态方法，不需要用线程对象.currentThread()，直接用Thread.currentThread()。

4.“当前”线程进入休眠：

Thread.sleep(time);
是一个静态方法，所以说如果在main方法中调用支线程.sleep(time),休眠的是main线程而不是支线程。

5.终止线程的休眠：

线程对象.Interrupt();
终止休眠靠的是try…catch的异常处理机制，Interrupt()方法执行后try语句块中还在进行sleep()的代码会报错，并终止sleep()执行，进入catch语句块。

6.终止线程的执行：

线程类中加一个成员变量boolean flag=true，run()方法中加一个if(flag==false){return;}条件判断，如果需要终止线程，调用setFlag()方法将flag置false即可。

五、线程调度：

  1. 常见的线程调度模型：
    （1）抢占式调度模型：
    线程优先级高的线程抢到CPU时间片的概率就高一些。java采用的就是抢占式模型。
    （2）均分式调度模型：
    平均分配CPU时间片，每个线程占有CPU时间片的时间一样。
    2.Java中与线程调度有关的方法：

（1）void serPriority(int newPriority)设置线程优先级

（2）int getPriority()获取线程优先级
最低优先级1
默认优先级5
最高优先级10

（3）static void yield()让位方法，暂停当前正在执行的线程对象，从运行状态回到就绪状态。注意：回到就绪状态后还可能会再次抢到时间片。

（4）void join();t.join()当前线程进入阻塞，t线程先执行，t执行完后当前线程再继续执行。

六、线程安全：重点

  1. 什么时候多线程并发会存在安全问题？
    多线程并发且对共享数据有修改的行为。

  2. 如何解决多线程安全问题？
    线程同步机制（线程排队执行）。
    线程同步会牺牲一部分效率。

  3. 两个模型：
    （1）同步线程模型：
    线程t1执行的时候，必须等待线程t2执行结束。属于多线程同步模型，效率较低，安全。
    （2）异步线程模型：
    线程各自执行，互不影响，属于多线程并发模型，效率高，不安全。

  4. 线程同步机制的语法：

synchronized(){

}

  • ()中写需要排队执行的多个线程的共享对象。
    假设t1.t2.t3.t4.t5五个线程。只希望t1.t2.t3排队，那么()写的是t1.t2.t3的共享对象，而这个对象对t4.t5来说不共享。
  • {}中写不同线程需要排队执行的代码。

synchronized 实例方法名(){}

  • 如果共享对象是this，并且需要同步的代码是整个方法体，建议用这种方式。否则用同步代码块的方式。

  1. 线程同步的实现原理：
    （1）java中每个对象都有一把锁。
    （2）假设t1.t2线程并发，开始执行代码的时候，肯定有先有后。
    （3）假设t1抢到时间片，先执行了，遇到synchronized，这个时候自动找()中共享对象的锁，找到之后占有这把锁，然后执行同步代码块中的程序，直到同步代码块执行完，t1才会释放这把锁。
    （4）假设t1已经占有这把锁，此时t2抢到时间片，也遇到synchronized，也会去占有()中共享对象的锁，但是这把锁已经被t1占有了，t2只能在同步代码块外面等待t1结束，直到t1释放锁，此时t2才可能抢到锁，进入自己的同步代码块执行。
    （5）占有到共享对象执行代码块。占有不到共享对象不执行代码块。

  2. 例子：模拟银行取款
    （1）场景：甲乙分别在前台和自助取款机对张三账户取款，丙在自助取款机对李四账户取款。
    （2）代码：

public class Test{
    public static void main(String args[]) {
        Account account1 = new Account("张三",10000);//创建账户对象张三
        AccountThread thread1 = new AccountThread(account1);//创建线程对象,对account1操作
        thread1.setName("自助取款机-001");
        AccountThread thread2 = new AccountThread(account1);//创建线程对象，account1操作
        thread2.setName("前台");
        thread1.start();//开启线程，模拟甲在自助取款机-001对张三的账户取款
        thread2.start();//开启线程，模拟乙在前台对张三的账户取款

        Account account2 = new Account("李四",7000);//创建账户对象李四
        AccountThread thread3 = new AccountThread(account2);//创建线程对象，account2操作
        thread3.setName("自助取款机-002");
        thread3.start();//开启线程，模拟丙在自助取款机-002对张三的账户取款
    }
}
class Account  {
    private String ID;
    private int balance;

    public Account() {
    }

    public Account(String ID, int balance) {
        this.ID = ID;
        this.balance = balance;
    }

    public String getID() {
        return ID;
    }

    public void setID(String ID) {
        this.ID = ID;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    public void drawMoney(int money){
        // synchronized (this) {//this表示当前对象
            int before = this.getBalance();
            int after = before-money;
            this.setBalance(after);
        // }
    }
}
class AccountThread extends Thread{//线程类
    Account account;
    public AccountThread(Account account){
            this.account = account;
    }
    public void run(){
        account.drawMoney(5000);//取款5000
        System.out.println("用户在"+Thread.currentThread().getName()+"对账户"+account.getID()+"取款成功,余额："+account.getBalance());
    }
}

（3）若不用synchronized关键字，可能出现的情况：
甲乙同时取款，甲取完款后余额没有及时更新，乙抢到时间片进入取款代码，即更新余额的代码没有抢到时间片，此时甲乙都是以10000元的余额开始取款，甲乙同时取5000后可能余额还是5000。
在这里插入图片描述
（4）使用synchronized关键字后，就不会出现上述不安全情况。但是注意：线程1和2会线程同步，排队执行，但是线程3不会排队，因为线程1,2是操作的同一个对象张三，线程3是操作的另一个对象李四。
即：若张三账户在前台取款则该账户同一时间不能在取款机取款，只有在前台取完款，余额发生变化后，张三账户才能在取款机取款。而这个机制对李四账户没有影响，李四可以在任何时间取款。
在这里插入图片描述

（7）面试题：

public class Test{
    public static void main(String args[]) {
        Test1 test = new Test1();
        Test1Thread tt1 = new Test1Thread(test);
        Test1Thread tt2 = new Test1Thread(test);
        tt1.setName("t1");
        tt2.setName("t2");
        tt1.start();
        try {
            Thread.sleep(1000);//目的是为了先开启线程tt1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tt2.start();
    }
}
class Test1  {
   public synchronized void dosome(){
       System.out.println("dosome begin");
       try {
           Thread.sleep(1000*4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("dosome end");
   }
    public void doother(){
        System.out.println("doother begin");
        System.out.println("doother end");
    }
}
class Test1Thread extends Thread{
    Test1 test1;
    public Test1Thread(Test1 test1){
            this.test1 = test1;
    }
    public void run(){
        if (Thread.currentThread().getName().equals("t1")){
            test1.dosome();
        }
        if (Thread.currentThread().getName().equals("t2")){
            test1.doother();
        }
    }
}

问题1：doother()方法执行的时候是否需要等待dosome()方法的结束？
答：不需要。因为doother()方法没有synchronized。tt1线程先执行，占有test对象的锁，执行dosome()方法,tt2线程若抢到时间片，则tt2线程执行，tt2执行doother()方法不需要获取对象test的锁，所以不需要等待。

问题2：doother()方法加上synchronized后执行的时候是否需要等待dosome()方法的结束？
答：需要。因为对象才有锁，方法没有锁，锁的是test对象而不是方法。tt1线程先执行，占有test对象的锁，执行dosome()方法,tt2线程若抢到时间片，tt2会去占有test锁，但是锁已经被tt1占了，所以tt2会等待test1锁被释放再执行。

public class Test{
    public static void main(String args[]) {
        Test1 test1 = new Test1();
        Test1 test2 = new Test1();
        Test1Thread tt1 = new Test1Thread(test1);
        Test1Thread tt2 = new Test1Thread(test2);
        tt1.setName("t1");
        tt2.setName("t2");
        tt1.start();
        try {
            Thread.sleep(1000);//目的是为了先开启线程tt1
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tt2.start();
    }
}
class Test1  {
   public synchronized void dosome(){
       System.out.println("dosome begin");
       try {
           Thread.sleep(1000*4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("dosome end");
   }
    public synchronized void doother(){
        System.out.println("doother begin");
        System.out.println("doother end");
    }
}
class Test1Thread extends Thread{
    Test1 test1;
    public Test1Thread(Test1 test1){
            this.test1 = test1;
    }
    public void run(){
        if (Thread.currentThread().getName().equals("t1")){
            test1.dosome();
        }
        if (Thread.currentThread().getName().equals("t2")){
            test1.doother();
        }
    }
}

问题3：doother()方法执行的时候是否需要等待dosome()方法的结束？
不需要。因为两个线程是针对不同对象的。

问题4：synchronized 都前加static 变成静态方法后，doother()方法执行的时候是否需要等待dosome()方法的结束？
需要。synchronized出现在静态方法上是类锁，锁的是类，一个类只有一把锁。只有对象和类才有锁，别的没有锁。

（8）死锁：
两个线程互锁，程序一直不能往下执行，应该避免。开发的时候尽量不要synchronized嵌套synchronized。

七、守护线程：

  1. java中线程分为两大类：
    一是：用户线程。
    二是：守护线程（后台线程），如垃圾回收器线程。
  2. 守护线程特点：
    一般守护线程是一个死循环，所有的用户线程只要结束，守护线程就自动结束。
    3.实现代码：
public class Test{
    public static void main(String args[]) {
       Thread t= new TestThread();
       t.setDaemon(true);//将线程变为守护线程
    }
}

class TestThread extends Thread{
    public void run(){
        while(true){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

八、定时器：

timer.schedule(定时任务对象，第一次执行时间，间隔多久执行一次);

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Test{
    public static void main(String args[]) throws ParseException {
        Timer timer = new Timer();
        //Timer timer = new Timer(true);//守护线程的方式
        SimpleDateFormat sdf = new SimpleDateFormat("yy-mm-dd  hh:mm:ss");
        Date firsttime = sdf.parse("2022-8-6  16:15:15");
        timer.schedule(new LogTimerTask(),firsttime,1000*2);
    }
}

class LogTimerTask extends TimerTask{

    @Override
    public void run() {
        //编写定时器需要执行的任务
        SimpleDateFormat sdf = new SimpleDateFormat("yy-mm-dd  hh:mm:ss");
        String s = sdf.format(new Date());
        System.out.println(s+"完成一次两秒内的数据备份");
    }
}

九、实现线程的第三种方式(带返回值)：

实现Callable接口，实现call()方法。
优点：可以获取线程的返回值。
缺点：效率低。
使用get()方法获取线程返回值。

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

public class Test{
    public static void main(String args[]) throws ExecutionException, InterruptedException {
        FutureTask fu = new FutureTask(new ThreadTest());//FutureTest类代理
        Thread t = new Thread(fu);
        t.start();
        Object s = fu.get();
        System.out.println(s);
    }
}
class ThreadTest implements Callable{

    @Override
    public Object call() throws Exception {
        int a=10;
        int b=10;
        return a+b;
    }
}

十、Object类的wait和notify方法：

  1. java中任何一个对象都有这两个方法。
  2. wait()方法和notify()方法不是通过线程对象调用。
  3. 两种方法必须建立在线程同步的基础上。
  4. 方法作用：
    （1）wait()方法的作用:让正在o对象上活动的线程进入等待状态，并且释放o的锁，直到被唤醒。
    （2）notify()方法的作用：唤醒o对象上正在等待的线程。notifyAll()唤醒o所有线程。
  5. 生产者和消费者模式：
    （1）什么是生产者消费者模式：
    对同一个仓库对象o，生产线程负责生产，消费线程负责消费，生产线程和消费线程达到均衡。
    （2）案例：
    仓库采用list集合。list集合中智能存储1个元素。1个元素就表示仓库满了。如果list集合中元素个数是0，就表示仓库空了。
import java.util.ArrayList;
import java.util.List;

public class Test{
    public static void main(String[] args) {
        List list = new ArrayList();//仓库
        Thread producer = new Thread(new Producer(list));//生产者线程
        Thread consumer = new Thread(new Consumer(list));//消费者线程
        producer.setName("生产者线程");
        consumer.setName("消费者线程");
        producer.start();
        consumer.start();
    }
}
class Producer implements Runnable{
    List list;

    public Producer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while(true) {//死循环一直生产
            synchronized (list) {
                if (list.size() >=1) {//仓库满
                    try {
                        list.wait();//生产者线程等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else{//仓库未满
                    Object obj = new Object();
                    list.add(obj);
                    System.out.println(Thread.currentThread().getName()+"生产了"+obj.toString());
                    list.notifyAll();//唤醒等待的线程，继续消费
                }
            }
        }
    }
}
class Consumer implements Runnable{
    List list;

    public Consumer(List list) {
        this.list = list;
    }

    @Override
    public void run() {
        while(true) {//死循环一直消费
            synchronized (list) {
                if (list.size() <= 0) {//仓库空
                    try {
                        list.wait();//消费者线程等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else{
                    Object obj = list.remove(0);
                    System.out.println(Thread.currentThread()+"购买了"+obj.toString());
                    list.notifyAll();//唤醒等待的线程，继续生产
                }
            }
        }
    }
}
姓蔡小朋友
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
1.4 线程的核心原理
天空鸟的博客
08-02 866
接下来，对线程的6种状态以及各种状态的进入条件做一个总结。1.NEW状态通过newThread(…)已经创建线程，但尚未调用start()启动线程，该线程处于NEW（新建）状态。虽然前面介绍了4种方式创建线程，但是其中的其他三种方式本质上都是通过newThread()创建线程，仅仅是创建了不同的target执行目标实例（如Runnable实例）。2.RUNNABLE状态Java把Ready（就绪）和Running（执行）两种状态合并为一种状态RUNNABLE（可执行）状态（或者可运行状态）。...
JAVA多线程编程详解-详细操作例子
03-24
4. **线程同步**：在多线程环境中，为了防止数据不一致性和竞态条件，Java 提供了多种同步机制，如 `synchronized` 关键字、`wait()` 和 `notify()` 方法、`ReentrantLock`、`Semaphore` 等。`synchronized` 可以...
cpu时间片
hjwsm1989的专栏
09-26 1701
时间片（timeslice）又称为“量子（quantum）”或“处理器片（processorslice）” 是分时操作系统分配给每个正在运行的进程微观上的一段CPU时间（在抢占内核中是：从进程开始运行直到被抢占的时间）。 现代操作系统（如：Windows、Linux、Mac OS X等）允许同时运行多个进程 —— 例如，你可以在打开音乐播放器听音乐的同时用浏览器浏览网页并下载文件。 事实
cpu时间片原理说明
tombaby_come的博客
09-28 1529
时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片，即该进程允许运行的时间，使各个程序从表面上看是同时进行的。如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。而不会造成CPU资源浪费。在宏观上：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。但在微观上：由于只有一个CPU，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。
java学习——守护线程
最新发布
m0_73245690的博客
04-15 367
我们在这里调用setDaemon()方法，把一个线程设置为守护线程。守护线程是在进程中所有线程都结束的时候的结束。这里我们开启了一个子线程，并把这个子线程设置为守护线程。守护线程是在所有线程结束后自动结束。所以我们使用场景一般在垃圾回收机制。2.守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束。1.用户线程：也叫工作线程，当线程的任务执行完成通知方式结束。我们可以看到，在主线程结束的时候，接下来，守护线程就结束了。3.常见的守护线程：垃圾回收机制。
多线程操作时操作系统时间片_从零开始自制操作系统（15）：内核多线程
weixin_39931362的博客
11-23 382
1.多线程原理：（1）概述：多线程是指CPU可以在一段时间中并行执行多个程序，比如我们可以一边听音乐、一边写代码（这两个程序可以“同时进行”，我们称之为多进程，而多进程实现的本质就是内核多线程）。实际上，针对多核CPU，可以将这两个程序放在不同的核上边执行，但是单核CPU没法这样，所以单核CPU的多线程只能在一个核上边短时间切换执行程序任务，由于切换的速度很快，这样使用者会感受到多个任务似乎是同时...
java线程锁与解锁,Java在不同的线程上锁定和解锁
weixin_36332394的博客
03-10 840
我有一个主线程和一个工作线程.主线程将任务添加到队列中,工作线程将其用于计算数据.在将对象放入队列之前,我在任务对象内的ReentrantLock对象(在主线程上)上调用锁.当工作线程完成从队列中的任务处理时,我称为解锁(在工作线程上).问题是我收到一个IllegalMonitorStateException,因为我在不同的线程上调用了锁定和解锁.我正在寻找可以在不同线程上执行此操作的替代锁定系统...
java 线程编程教程
02-03
2. **线程调度**：Java采用抢占式调度，高优先级的线程可能抢占低优先级线程的CPU时间片。此外，还有定时器调度，如ScheduledExecutorService，可以设置延迟或周期性执行任务。 3. **线程控制**：可以使用join()...
多线程示例，同时同步到进度条
08-11
在单核处理器中，多线程是通过时间片轮转的方式实现的，即操作系统快速切换线程的执行，给人造成同时执行的错觉。在多核处理器中，线程可以真正地并行执行，提高系统的整体效率。在Java、Python、C#等编程语言中，都...
多线程经典例子
03-30
为此，Java提供了各种同步机制，如`synchronized`关键字、`wait()`, `notify()`和`notifyAll()`方法、以及`ReentrantLock`等高级锁。合理使用这些机制可以避免线程间的不和谐交互。 文件名"多线程"可能是一个包含多...
操作系统课程设计-时间片轮转算法java实现.doc
09-25
2. **多线程**：Java语言提供了内置的多线程支持，通过`Thread`类或者`Runnable`接口实现。在时间片轮转算法中，每个进程可以被视为一个线程，通过`start()`方法启动，并在`run()`方法中实现进程的逻辑。 3. **线程...
CPU时间片轮转法
01-03
这是一算法，关于时间片轮转的算法，操作系统上的
Java多线程学习笔记 - 十、可重入锁ReentrantLock
学以致用 知行合一
04-04 617
在Java 5.0之前，在协调对共享对象的访问时可以使用的机制只有synchronized和volatile。Java 5.0增加了一种新的机制：ReentrantLock。 在大多数情况下，内置锁都能很好地工作，但在功能上存在一些局限性，例如，无法中断一个正在等待获取锁的线程，或者无法在请求获取一个锁时无限地等待下去。内置锁必须在获取该锁的代码块中释放，这就简化了编码工作，并且与异常处理操作实现了很好的交互，但却无法实现非阻塞结构的加锁规则。
JavaSE初级入门课程(下)
03-12
该课程由付强老师主讲，系统的、全面的、具体的讲解了java进阶的知识。可以使初级的学员入门。
Java线程的CPU时间片
weixin_34024034的博客
04-29 1751
Java中线程会按优先级分配CPU时间片运行，那么线程什么时候放弃CPU的使用权？可以归类成三种情况： 当前运行线程主动放弃CPU，JVM暂时放弃CPU操作（基于时间片轮转调度的JVM操作系统不会让线程永久放弃CPU，或者说放弃本次时间片的执行权），例如调用yield()方法。 当前运行线程因为某些原因进入阻塞状态，例如阻塞在I/O上。 当前运行线程结束，即运行完run()方法里面的任...
简单个人理解（一）：对于时间片和Java中进程和线程
凝孑哒哒哒的博客
01-29 1384
简单个人理解（一）：对于时间片和Java中进程和线程 一.时间片 如果大家想要清楚清晰的了解进程和多线程的关系，那我们就不得不先提一个叫做时间片的东东，让我们先来瞅瞅百度词条是怎么说的： - 时间片（timeslice）又称为“量子（quantum）”或“处理器片（processor slice）”是分时操作系统分配给每个正在运行的进程微观上的一段CPU时间（在抢占内核中...
java中Lock的用法以及Lock与synchronized的区别
TimeTDIT的博客
12-10 2125
初识Lock以及Lock和synchronized的区别
java 锁实现——volatile、synchronized、ReentrantLock
休息的风的专栏
10-14 1246
ava的锁实现，有最轻量级volatile同步机制，有基于jvm语义的synchronized关键字，也有基于AQS实现的重入锁，读写锁。本篇博客主要分析volatile的语义，synchronized在jvm层面的实现以及ReentrantLock是如何基于AQS实现的。
java线程的一点感悟(sleep,wait,synchronized,时间片等)
ccityzh的博客
04-15 1840
志在以实例的方式描述线程中使用的一些容易混淆概念的方法。1、sleep()方法不释放锁public class SleepFunction { static final Object obj = new Object(); public static void main(String[] args) { new Thread(new Runnable() { public void r...
Java多线程-多线程知识点总结和企业真题
02-04
Java多线程--多线程知识点总结和企业真题

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

姓蔡小朋友

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值