Java—多线程

已于 2022-06-21 21:00:40 修改
阅读量983 收藏 1
点赞数
分类专栏： 笔记 文章标签： java
于 2022-03-28 14:55:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61843013/article/details/123795415
版权

目录

一、线程相关概念

1.1 程序

1.2 进程

1.3 什么是线程

1.4 其它相关概念

二、线程基本使用

2.1 继承Thread类，重写run方法

2.2 实现Runnable接口，重写run方法

2.3 继承Thread和实现Runnable的区别

三、线程终止

3.1 基本说明

四、线程常用方法

4.1 常用方法第一组

4.2 注意事项和细节

4.3 常用方法第二组

4.4 用户线程和守护线程

五、线程的生命周期

5.1 JDK中用Thread.State枚举表示了线程的几种状态

5.2 线程状态转换图

5.3 写程序查看线程状态

六、Synchronized

6.1 线程同步机制

6.2 同步具体方法—Synchronized

6.3 有关锁和条件的关键之处

七、互斥锁

7.1 基本介绍

7.2 注意事项和细节

八、线程的死锁

8.1 基本介绍

九、释放锁

9.1 下面操作会释放锁

9.2 下面操作不会释放锁

十、守护线程

一、线程相关概念

1.1 程序

        程序是为完成特定任务，用某种语言编写的一组指令的集合。简单的说就是我们写的代码

1.2 进程

        ①进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间

        ②进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：是它自身的产生、存在和消亡的过程

1.3 什么是线程

        ①线程是由进程创建的，是进程的一个实体

        ②一个进程可以拥有多个线程

1.4 其它相关概念

        ① 单线程：同一个时刻，只允许执行一个线程

        ② 多线程：同一个时刻，可以执行多个线程。比如：一个qq进程可以同时打开多个聊天窗口，一个迅雷进程可以同时下载多个文件

        ③ 并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发

        ④ 并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行

二、线程基本使用

在java中线程来使用有两种方法

        1.继承Thread类，重写run方法

        2.实现Runnable接口，重写run方法

2.1 继承Thread类，重写run方法

package com.learn.threaduse;

/**
 * @author 咕咕猫
 * @version 1.0
 * 演示通过继承Thread类创建线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象，可以当作线程使用
        Cat cat = new Cat();

        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0()是本地方法，是JVM调用，底层是c/c++实现
            //真正实现多线程的效果是start0()
            private native void start0();
            (3)
         */
        cat.start();//启动线程 ->最终会执行cat的run方法
//        cat.run();//run方法就是一个普通的方法，没有真正的启动一个线程，就会把run方法执行完毕后才继续向下执行
        //说明：当main线程启动一个子线程 Thread-0，主线程不会阻塞
        //这时，主线程和子线程是交替执行的
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        for (int i = 0; i < 60; i++) {
            System.out.println("主线程i=" + i);
            //让主线程休眠
            Thread.sleep(1000);
        }

    }
}

//说明
//1. 当一个类继承了Thread类，该类就可以当作线程使用
//2. 我们会重写run方法，写上自己的业务代码
//3. run Thread类实现了Runnable接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class Cat extends Thread{

    int times = 0;
    @Override
    public void run() { //重写run方法，写上自己的业务逻辑

        while (true) {
            System.out.println("喵喵，我是小猫咪~" + (++times) + "线程名=" + Thread.currentThread().getName()) ;
            //让该线程休眠一秒 ctrl + alt + t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 80){ //当times到80,就退出while循环，这时线程也就退出..
                break;
            }
        }

    }
}

2.2 实现Runnable接口，重写run方法

  • 说明

        ①java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然已经不可能了

        ②java设计者们提供了另一个方式创建线程，就是通过实现Runnable接口来创建线程

package com.learn.threaduse;

/**
 * @author 咕咕猫
 * @version 1.0
 * 通过实现Runnable接口来开发线程
 */
public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start(); //这里不能调用start
        //创建一个Thread对象，把dog对象(实现了Runnable接口)放入Thread
        Thread thread = new Thread(dog);
        thread.start();


        Tiger tiger = new Tiger();//实现了Runnable
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}


class Animal{}
class Tiger extends Animal implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫...");
    }
}



//线程代理类，模拟了一个极简的Thread类
class ThreadProxy implements Runnable {

    private Runnable target = null; //属性，类型是Runnable

    @Override
    public void run() {
        if(target != null) {
            target.run(); //动态绑定 (运行类型是Tiger)
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start(){
        start0(); //这个方法是真正实现多线程的方法
    }
    public void start0(){
        run();
    }
}




class Dog implements Runnable { //通过实现Runnable接口开发线程

    int count = 0;
    @Override
    public void run() { //普通方法
        while(true) {
            System.out.println("小狗汪汪叫..hi " + (++count) + Thread.currentThread().getName());
            //休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 10){
                break;
            }
        }
    }
}

2.3 继承Thread和实现Runnable的区别

        ①从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口

        ②实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承多线程，建议使用Runnable

三、线程终止

3.1 基本说明

        ①当线程完成任务后，会自动退出

        ②还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式

package com.learn.exit_;

/**
 * @author 咕咕猫
 * @version 1.0
 */
public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();
        //如果希望main线程去控制t1线程的终止，就必须可以修改loop
        //让t1退出run方法，从而终止t1线程 -> 通知方式

        System.out.println("main线程休眠10秒...");
        Thread.sleep(10 * 1000);
        t1.setLoop(false);
    }
}
class T extends Thread {
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50); //让线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中..." + (++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

四、线程常用方法

4.1 常用方法第一组

① setName：设置线程名称，使之与参数name相同

② getName：返回该线程的名称

③ start：使该线程开始执行；Java虚拟机底层调用该线程的start0方法

④ run：调用线程对象的run方法

⑤ setPriority：更改线程的优先级

⑥ getPriority：获取线程的优先级

⑦ sleep：在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

⑧ interrupt：中断线程

4.2 注意事项和细节

①start底层会创建新的线程调用run，run就是一个简单的方法调用，不会启动新线程

②线程优先级的范围

③interrupt是中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠的线程

④sleep：线程的静态方法，使当前线程休眠

4.3 常用方法第二组

① yield：线程的礼让。让出cpu，让其它线程执行，但礼让的时间不确定，所以也不一定礼让成功

② join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

4.4 用户线程和守护线程

①用户线程：也叫工作线程，当线程的任务执行完或通知方式结束

②守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束  setDaemon

③常见的守护线程：垃圾回收机制

package com.learn.method;

/**
 * @author 咕咕猫
 * @version 1.0
 */
public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();

        //如果希望当main线程结束后，子线程可以自动结束
        //只需要将子线程设置成守护线程即可
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();
        for (int i = 1; i <= 10; i++) {
            System.out.println("王宝强在辛苦的工资");
            Thread.sleep(1000);
        }
    }
}

class MyDaemonThread extends Thread {
    @Override
    public void run() {
        for ( ; ; ) { //无限循环
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("马蓉和宋喆快乐聊天...");
        }
    }
}

五、线程的生命周期

5.1 JDK中用Thread.State枚举表示了线程的几种状态

5.2 线程状态转换图

5.3 写程序查看线程状态

package com.learn.state_;

/**
 * @author 咕咕猫
 * @version 1.0
 */
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + " 状态 " + t.getState());
        t.start();

        while (Thread.State.TERMINATED != t.getState()) {
            System.out.println(t.getName() + " 状态 " + t.getState());
            Thread.sleep(500);
        }
        System.out.println(t.getName() + " 状态 " + t.getState());
    }
}

class T extends Thread {
    @Override
    public void run() {
        while(true) {
            for (int i = 0; i < 10; i++) {
                System.out.println("hi" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            break;
        }
    }
}

六、Synchronized

6.1 线程同步机制

        ①在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就是使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性

        ②可以理解问：线程同步。即当有要给线程在对内存进行操作时，其它线程都不可以对这个内存地址进行操作，直到该线程该线程完成操作，其它线程才能对该内存地址进行操作

6.2 同步具体方法—Synchronized

1.同步代码块

synchronized(对象) {    //得到对象的锁，才能操作同步代码

        //需要被同步的代码；

}

2. synchronized还可以放在方法声明中，表示整个方法为同步方法

public synchronized void m(String name) {

        //需要被同步的代码

}

6.3 有关锁和条件的关键之处

  • 锁用来保护代码片段，任何时刻只能有一个线程执行被保护的代码
  • 锁可以管理视图进入被保护代码段的线程
  • 锁可以拥有一个或多个相关的条件对象
  • 每个条件对象管理那些已经进入被保护的代码段但还不能运行的线程
package com.learn.syn_;

/**
 * @author 咕咕猫
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票100张
 */
@SuppressWarnings({"all"})
public class SellTicket {
    public static void main(String[] args) {
//
//        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//start启动售票线程

        //测试
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程窗口
        new Thread(sellTicket03).start();//第2个线程窗口
        new Thread(sellTicket03).start();//第3个线程窗口
    }
}

//实现接口方式，使用synchronized实现线程同步
class SellTicket03 implements Runnable {

    private int ticketNum = 100; //让多个线程共享ticketNum
    private boolean loop = true;

    public synchronized void sell(){ //同步方法，在同一个时刻只能有一个线程来执行run方法
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                loop = false;
                return;
            }

            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口" + Thread.currentThread().getName() + " 售出一张票" +
                    " 剩余票数=" + (--ticketNum));
        }
    @Override
    public void run() {
        while (loop) {
            sell(); //sell方法是一个同步方法
        }
    }
}



//使用Thread方式
class SellTicket01 extends Thread {

    private static int ticketNum = 100; //让多个线程共享ticketNum

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

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口" + Thread.currentThread().getName() + " 售出一张票" +
                    " 剩余票数=" + (--ticketNum));
        }
    }
}

//实现接口方式
class SellTicket02 implements Runnable {

    private int ticketNum = 100; //让多个线程共享ticketNum

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

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口" + Thread.currentThread().getName() + " 售出一张票" +
                    " 剩余票数=" + (--ticketNum));
        }
    }
}

6.3 分析同步原理

七、互斥锁

7.1 基本介绍

        ①在Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性

        ②每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任意时刻只能有一个线程访问该对象

        ③关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任意时刻只能由一个线程访问

        ④同步的局限性：导致程序的执行效率要降低

        ⑤同步方法(非静态的)的锁可以是this，也可以是其它对象(要求是同一个对象)

        ⑥同步方法(静态的)的锁为当前类本身

package com.learn.syn_;

/**
 * @author 咕咕猫
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票100张
 */
public class SellTicket {
    public static void main(String[] args) {
//
//        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//        //这里我们会出现超卖..
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//start启动售票线程

        //测试
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();//第1个线程窗口
        new Thread(sellTicket03).start();//第2个线程窗口
        new Thread(sellTicket03).start();//第3个线程窗口
    }
}

//实现接口方式，使用synchronized实现线程同步
class SellTicket03 implements Runnable {

    private int ticketNum = 100; //让多个线程共享ticketNum
    private boolean loop = true;
    Object object = new Object();

    //同步方法(静态的)的锁为当前类本身
    //1. public synchronized static void m1() {} 的锁是加在SellTicket03.class
    //2. 如果要在静态方法中实现一个同步代码块，用 类名.class 来处理
    /*
        synchronized (SellTicket03.class) {
                System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
    public static void m2(){
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }



    //说明
    //1. public synchronized void sell(){} 就是一个同步方法
    //2. 这时锁是在this对象
    //3. 也可以在代码块上写 synchronized，同步代码块，互斥锁还是在this对象
    public /*synchronized*/ void sell(){ //同步方法，在同一个时刻只能有一个线程来执行run方法

            synchronized (/*this*/ object) {
                if (ticketNum <= 0) {
                    System.out.println("售票结束...");
                    loop = false;
                    return;
                }

                //休眠50毫秒
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("窗口" + Thread.currentThread().getName() + " 售出一张票" +
                        " 剩余票数=" + (--ticketNum));
            }
        }
    @Override
    public void run() {
        while (loop) {
            sell(); //sell方法是一个同步方法
        }
    }
}



//使用Thread方式
// new SellTicket01().start(); //必须保证多个线程的锁是同一个，此处不是共享的对象，所以锁不住
// new SellTicket01().start();

class SellTicket01 extends Thread {

    private static int ticketNum = 100; //让多个线程共享ticketNum

    //锁不住
    public void m1() {
        synchronized (this) {
            System.out.println("hello");
        }
    }



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

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口" + Thread.currentThread().getName() + " 售出一张票" +
                    " 剩余票数=" + (--ticketNum));
        }
    }
}

//实现接口方式
class SellTicket02 implements Runnable {

    private int ticketNum = 100; //让多个线程共享ticketNum

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

            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口" + Thread.currentThread().getName() + " 售出一张票" +
                    " 剩余票数=" + (--ticketNum));
        }
    }
}

7.2 注意事项和细节

        ①同步方法如果没有使用static修饰：默认锁对象为this

        ②如果方法使用static修饰：默认锁对象为当前类.class

八、线程的死锁

8.1 基本介绍

       多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生

       生活化案例来理解死锁：妈妈说：你先完成作业才能让你玩手机；小明：你先让我玩手机我才能完成作业

package com.learn.syn_;

/**
 * @author 咕咕猫
 * @version 1.0
 * 模拟线程死锁
 */
public class DeadLock_ {
    public static void main(String[] args) {
        DeadLockDemo A = new DeadLockDemo(true);
        DeadLockDemo B = new DeadLockDemo(false);
        A.setName("线程A");
        B.setName("线程B");
        A.start();
        B.start();

    }
}


//
class DeadLockDemo extends Thread {
    static Object o1 = new Object(); //保证多线程共享一个对象，这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) { //构造器
        this.flag = flag;
    }

    @Override
    public void run() {

        //业务逻辑分析
        //1. 如果flag为T，线程A就会先得到/持有o1对象锁，然后尝试去获取o2对象锁
        //2. 如果线程A得不到o2对象锁，就会Blocked
        //3. 如果flag为F，线程B就会先得到/持有o2对象锁，然后尝试去获取o1对象锁
        //4. 如果线程B得不到o1对象锁，就会Blocked
        if (flag) {
            synchronized (o1) {//对象互斥锁, 下面就是同步代码
                System.out.println(Thread.currentThread().getName() + " 进入 1");
                synchronized (o2) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 2");
                }
            }
        }else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + " 进入 3");
                synchronized (o1) { // 这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + " 进入 4");
                }
            }
        }
    }
}

九、释放锁

9.1 下面操作会释放锁

        ①当前线程的同步方法、同步代码块执行结束

        ②当前线程在同步代码块、同步方法中遇到break、return

        ③当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束

        ④当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁

9.2 下面操作不会释放锁

①线程执行同步代码块或同步方法时，程序调用了Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁

②线程执行同步代码块时，其它线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁

提示：应尽量避免使用suspend()和resume()来控制线程，这两个方法不再推荐使用

十、守护线程

调用setDaemon(true)把该线程标记为守护线程

守护线程的唯一用途是为其他线程提供服务。当只剩下守护线程时，虚拟机就退出了

咕咕猫_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA多线程：sleep(0)、sleep(1)、sleep(1000)的区别（四）
血煞长虹 的专栏
02-19 4770
三者都使用了参数，只是睡眠的时间长短不一样。如果单单从睡眠时间结束后的结果来看，三者的作用是一样的，都是不释放锁，都是睡醒后重新同其他线程竞争CPU的执行权，问题就出在0、1、1000，这段时间发生了什么。 0，意味着没有休息，离开进入下一轮的CPU执行权竞争中，可能竞争成功也可能失败。 1，是一样的，仅仅是休息1毫秒后，离开进入下一轮的竞争，仅仅是在这1毫秒内进入了等待状态。 1000，相对于1，此时的1000就不难理解了，它仅仅是休息的时间（放弃竞争CPU执行权）的时间更长。
多线程基础
qq_37348714的博客
03-04 86
多线程小结程序、进程、线程 程序、进程、线程
Java多线程详解
luojias的博客
05-09 596
1线程的创建和启动 1.1thread类创建线程类 package ThreadLearnDemo01; public class FirstThread extends Thread{ private int i; public void run(){ for(;i<100;i++) { System.out.println(this.getName()+" "+i); } } public
C# Task.Delay(1000) 与 Thread.Sleep(1000)的区别
最新发布
qq_44967213的博客
05-27 438
在 C# 中都用于引入延迟，但它们之间存在显著的差异，主要体现在它们的行为和用途上。在行为和用途上有显著的区别。在编写现代、高效且响应性强的应用程序时，通常建议使用。
多线程概述
m0_71212413的博客
11-13 1127
多线程
Thread.sleep()线程休眠的时间
qq_38875964的博客
07-25 4447
如果Thread.sleep()休眠时间到了之后线程是立即执行的，那最后打印出来的结果会是1000，但实际情况总是大于1000的，其原因是Thread.sleep()方法的作用是使线程主动放弃cpu的执行权，并在休眠的这段时间内不参与cpu的竞争，在休眠结束后，线程并不能马上得到执行，而是进入就绪状态，参与cpu抢占，只有得到cpu的执行权才能继续执行，所以线程的休眠时间总是大于设置的时间的，并且当cpu越忙的时候这个误差越大。
线程的生命周期以及sleep()方法和wait()方法
weixin_47414034的博客
04-26 913
共享对象调用wait方法：obj.wait()，当前线程释A放锁，进入waiting阻塞状态，除非其他线程调用共享对象obj.notify()方法唤醒这个线程，线程A就会去竞争试图重新获得锁，如果获得锁就进入运行态，如果没有获得锁就进入blocked阻塞状态。线程休眠指定时间，不会释放锁，也就是线程即使休眠也是一直保持锁的所有权的，等休眠时间一过，马上进入运行态，不用再去和其他处于blocked状态的线程一起竞争锁。sleep方法和wait()方法的区别。t1我被唤醒了，我又重新开始运行了。
调用Sleep()函数并不是说等该线程休眠1秒之后继续执行它
Zzzzzz_m的博客
09-17 1012
调用Sleep()函数并不是说等该线程休眠1秒之后继续执行它 引用此博主的解答：https://blog.csdn.net/sinat_41144773/article/details/89532788 Thread.Sleep(1000) 意思是在未来的1秒内本线程不参与CPU竞争，1秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束，即使这个时候恰巧轮到操作系统进行CPU 分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其
Java之线程
weixin_54076783的博客
11-09 748
例如A线程是第一个访问这个房间的，那么A线程就直接领取房间门口的钥匙进入房间，后面的线程B和线程C也来到房间门口，但线程B和线程C需要阻塞等待（进入中断状态）线程A从房间出来归还钥匙后才能领取钥匙进入房间。创建一个Thread对象，参数target是Runnable接口类型的对象，此构造方法将实现Runnable接口的类的对象放在Thread对象中，启动线程时会执行target对象的run()方法。//设定某个线程的优先权，默认为5，最低为1，最高为10,处于就绪队列中的线程优先权越高，越先被执行。
Java Thread和Runnable详解
hongxue8888的博客
01-01 1044
1、继承thread方式 //1、继承Thread类 public class Student extends Thread { private String name; private Punishment punishment; public Student(String name, Punishment punishment) { //2、调用Thre...
110.Thread.sleep(1000)；
qq_31426093的博客
04-26 205
package com.itheima.threaddemo6; public class MyRunnable implements Runnable{ @Override public void run() { for (int i = 0; i < 100; i++) { try { Thread.sleep(1000); } catch (InterruptedException.
Java之Thread.sleep()浅析
ldcaws的专栏
02-11 2080
在java开发中，经常会用到Thread.sleep(1000);类似的语句来使线程挂起一段时间，那么底层的逻辑是怎么操作的呢？ 问题1：假设现在时间是2022-1-1 8:00:00.000，若是调用了Thread.sleep(1000); 在2022-1-1 8:00:01.000 时，这个线程会不会继续执行？ 问题2：Thread.sleep(1000);是挂起了0毫秒，那与去掉这句代码有什么区别？ 说起线程，其底层就要了解一下操作系统原理了，操作系统主要使用window和linux，windows中
java sleep和wait的区别和联系
iteye_7202的博客
08-10 114
第一种解释： 功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步锁. 还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用 interreput()来强行打断;wait()可以用notify()直接唤起. 第二种解释： sleep是Thr...
JAVA多线程实现的四种方式
weixin_30810239的博客
11-06 965
Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。 其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。 1、继承Thread类创建线程Thread类本质上是实现了Runn...
Thread(target)之run()方法
inspiredbh的博客
02-10 4503
分析Thread(target)调用run()方法之前先来分析调用start()方法是如何运行的 不论是继承Thread类创建线程还是实现Runnable接口创建线程，启动线程一般都是调用Thread类的start()方法，然后由虚拟机自动调用Thread类的run()方法。Thread源码中如下：可以发现调用过程 1.首先打开start()方法： public synchronize
Java基础 线程2 线程的基本使用
sun1995sun的博客
03-20 569
线程的基本使用 案例1 线程应用案例1-继承Thread类 1、请编写程序，开启一个线程，该线程每隔1秒，在控制台输出“喵喵，我是小猫咪" 2、对上题进行改：当输出80次时，结束该线程 3、使用JConsole监控线程执行情况，并画出程序示意图 //查看cpu核心数/线程数 /** * @ClassName CpuNum * @Description * @Author 小黄debug * @Date 2022/3/20 13:01 * @Version 1.0 **/ publ
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值