java_线程

已于 2022-04-17 10:55:32 修改
阅读量949 收藏
点赞数
分类专栏： java笔记 文章标签： java
于 2022-04-06 00:07:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binnnnnnn_/article/details/123980281
版权

一、线程相关概念

（一）程序

在这里插入图片描述

（二）进程

在这里插入图片描述
在这里插入图片描述

（三）线程

在这里插入图片描述

（四）其他相关概念

在这里插入图片描述
在这里插入图片描述

		Runtime runtime = Runtime.getRuntime();
        //获取当前电脑cpu数量
        int cpuNums = runtime.availableProcessors();
        System.out.println("cpuNums" + cpuNums);

二、线程基本使用

（一）创建线程的两种方式

这里是引用
在这里插入图片描述

（二）线程应用案例1-继承Thread类

在这里插入图片描述
要等所有线程执行完毕才会退出
在这里插入图片描述
在多线程里面，主线程结束，子线程还没结束这是可以的
要所有的线程都结束了,然后进程才结束,然后退出程序

public class Thread01 {
    public static void main(String[] args) throws InterruptedException{
        //演示通过Thread类创建线程
        //创建Cat对象，可以当做线程
        Cat cat = new Cat();
        //cat.start();//启动线程
        cat.run();//run方法就是一个普通的方法，并没有启动线程，就会把run方法执行完毕，才会向下执行
        
        //说明：main线程启动一个子线程 Tread-0,主线程不会阻塞，会继续执行
        //这时，主线程和子线程交替执行
        System.out.println("主线程继续执行" + Thread.currentThread().getName());//主线程名称
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程 i=" + i);
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}
//1.当一个类继承了Thread 类，该类就可以当成线程使用
//2.我们会重写run方法，写上自己的业务代码
//3.run Thread 类，实现了Runnable 接口的run方法
class Cat extends Thread {
    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的逻辑
        while(true) {
            //该线程每隔1秒，在控制台输出“喵喵，我是小猫咪“
            System.out.println("喵喵，我是小猫咪" + (++times) + Thread.currentThread().getName());
            //快捷键 ctrl+alt+t
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 8) {
                break;//当times等于8，退出，线程也退出
            }
        }
    }
}

总结：
为什么是start?

调用cat.start()才会真正启动线程，所有线程执行完毕才结束程序
调用cat.run()不会真正启动线程，线程名称是main

在这里插入图片描述
在这里插入图片描述

（三）线程应用案例2-实现Runnable接口

这里是引用
在这里插入图片描述

package com.hapedu;

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();
        ThreadProxy threadProxy = new ThreadProxy(tiger);

    }
}

class Animal {}
class Tiger extends Animal implements Runnable {
    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫");
    }
}

class ThreadProxy implements Runnable {

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


    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

    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("小狗汪汪叫" + (++count) + Thread.currentThread().getName());
            //休眠一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

（四）线程使用应用案例-多线程执行

这里是引用

package com.hapedu;

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

        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
    }
}
class T1 implements Runnable {
    int count = 0;
    @Override
    public void run() {
        while (true) {
            //每隔1秒输出“hello，world”，输出10次
            System.out.println("hello,world " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }

    }
}
class T2 implements Runnable {
    int count = 0;
    @Override
    public void run() {
        while (true) {
            //每隔1秒输出“hello，world”，输出10次
            System.out.println("hi " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                break;
            }
        }

    }
}

（五）继承Thread VS 实现Runnable的区别

这里是引用
在这里插入图片描述

package com.hapedu.ticket;

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();//启动售票线程

        System.out.println("===使用实现接口方式类售票===");
        SellTicket02 sellTicket02 = new SellTicket02();

        new Thread(sellTicket02).start();//第1个线程-窗口
        new Thread(sellTicket02).start();//第2个线程-窗口
        new Thread(sellTicket02).start();//第3个线程-窗口
    }
}
//使用Thread方式
class SellTicket01 extends Thread {

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

    @Override
    public void run() {
        while(true) {
            if(ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }
            //休眠50毫秒
            try {
                Thread.sleep(100);
            } 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(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));
        }
    }
}

三、线程终止

（一）基本说明

在这里插入图片描述

package com.hapedu.exit_;

public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();

        //如果希望main线程去控制t1 线程的终止，必须可以修改
        //让t1 退出run方法，从而终止t1 线程->通知方式

        //让主线程休眠10秒，再通知t1线程退出
        System.out.println("main线程休眠10秒");
        Thread.sleep(10 * 1000);//alt+enter
        t1.setLoop(false);
    }
}

class T extends Thread {
    int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 线程还在运行" + (++count));
        }
    }

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

四、线程常用方法

（一）常用方法第一组

这里是引用

package com.hapedu.exit_;

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        t1.setName("老韩");
        t1.setPriority(Thread.MIN_PRIORITY);
        t1.start();//启动子线程

        //主线程打印5个hi，就中断子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi" + i);
        }
        System.out.println(t1.getName() + " 线程的有线程" + t1.getPriority());//1
        t1.interrupt();//当执行到这里，就会中断 t线程的休眠
    }
}
class T1 extends Thread {//自定义线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                System.out.println(Thread.currentThread().getName() + " 吃包子~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch一个异常，可以加入自己的业务代码
                //InterruptedException捕获到一个中断异常
                System.out.println(Thread.currentThread().getName() + " 被 interrupt了");
            }
        }
    }
}

（二）注意事项和细节

在这里插入图片描述

（三）常用方法第二组

在这里插入图片描述

package com.hapedu.method;

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();
        for (int i = 1; i <=20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了" + i + " 包子");
            if (i == 5) {
                System.out.println("主线程(小弟) 让 子线程（老大）先吃");
                //join 线程插队，一定成功
                // t2.join();//这里相当于让t2线程先执行完毕
                Thread.yield();
                System.out.println("子线程（老大）, 主线程(小弟) 接着吃。。");
            }
        }

    }
}
class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程（老大） 吃了 " + i + " 个包子");
        }

    }
}

（四）课堂练习

在这里插入图片描述

package com.hapedu.exercise;

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new T());
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            if( i == 5) {
                t.start();
                t.join();
            }
            Thread.sleep(1000);
        }
    }
}
class T implements Runnable {
    private int count = 0;
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程hello" + (++count));
            if (count == 10) {
                break;
            }
        }
    }
}

（五）用户线程和守护线程

在这里插入图片描述

package com.hapedu.exercise;

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 {
    public void run() {
        for (;;) {//无限循环
            try {
                Thread.sleep(50);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程");
        }
    }
}

五、线程的生命周期

（一）JDK总用Thread.State枚举表示了线程的几种状态

在这里插入图片描述
在这里插入图片描述

package com.hapedu.state;

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(1000);
        }
        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

在这里插入图片描述

package com.hapedu.syn;

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();//启动售票线程

//        System.out.println("===使用实现接口方式类售票===");
//        SellTicket02 sellTicket02 = new SellTicket02();
//
//        new Thread(sellTicket02).start();//第1个线程-窗口
//        new Thread(sellTicket02).start();//第2个线程-窗口
//        new Thread(sellTicket02).start();//第3个线程-窗口

        //测试一把
        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;//控制run变量
    public synchronized void sell() {//用的是同步方法，在同一时刻，只能有一个线程操作来执行sell方法

        if(ticketNum <= 0) {
            System.out.println("售票结束...");
            loop = false;
            return;
        }
        //休眠50毫秒
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                + " 剩余票数=" + (--ticketNum));
    }

    @Override
    public void run() {//用的是同步方法，在同一时刻，只能有一个线程操作来执行run方法
        while(loop) {
            sell();
        }
    }
}

（三）分析同步原理

在这里插入图片描述

七、互斥锁

（一）基本介绍

在这里插入图片描述

（二）使用互斥锁synchronized来解决售票问题

package com.hapedu.syn;

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

        //测试一把
        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;//控制run变量
    Object object = new Object();

    //同步方法（静态的）的锁为当前类本身
    //1.public synchronized static void m1() {} 锁是加在SellTicket03.class
    //2.如果在静态方法中，实现一个同步代码块
    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 ,同步代码块

    public  void sell() {
        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() {//用的是同步方法，在同一时刻，只能有一个线程操作来执行run方法
        while(loop) {
            sell();
        }
    }
}

（三）注意事项和细节

在这里插入图片描述

八、线程的死锁

（一）基本介绍

在这里插入图片描述

package com.hapedu.syn;

import java.util.TreeMap;

public class DeadLock_ {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        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 为True ,线程A就会持有o1对象锁，然后尝试去获取o2对象锁
        //2.如果线程A得不到o2对象锁，就会Blocked
        //3.如果flag 为false ,线程B就会先得到o2对象锁（else）然后尝试去获取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");
            }
        }
    }}
}

九、释放锁

（一）下面操作会释放锁

在这里插入图片描述

（二）下面操作不会释放锁

在这里插入图片描述

十、本章作业

（一）编程题

在这里插入图片描述
在这里插入图片描述

package com.hapedu.homework;


import java.util.Scanner;

public class Homework01 {

    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        a.start();
        b.start();
    }
}
class A extends Thread {
    private boolean loop =true;
    @Override
    public void run() {
        while (loop) {
            System.out.println((int)(Math.random()*100 + 1));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}
class B extends Thread {
    private A a;
    private Scanner scanner = new Scanner(System.in);

    public B(A a) {//构造器中，直接传入A对象
        this.a = a;
    }

    @Override
    public void run() {
        while (true) {
        //接受用户的输入
        System.out.println("请输入你的指令");
        char key = scanner.next().toUpperCase().charAt(0);
        if(key == 'Q') {
            //以通知的方式q结束A线程
            a.setLoop(false);
            System.out.println("B线程退出.");
            break;
        }
    }

    }
}

在这里插入图片描述
在这里插入图片描述

package com.hapedu.homework;

public class Homework02 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread1 = new Thread(t);
        thread1.setName("t1");
        Thread thread2 = new Thread(t);
        thread2.setName("t2");
        thread1.start();
        thread2.start();

    }
}
//编程取款的线程
//1.因为这里涉及到多个线程共享资源，所以我们使用实现Runnable方式
class T implements Runnable {
    private int money = 10000;

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

            //1.这里使用了synchronized 实现了线程同步
            //2.当多个线程执行到这里时，就会去争夺this对象锁
            //3.哪个线程争取到this对象，就执行synchronized代码块，执行完，就会释放this对象锁
            //4.争夺不到this对象锁，就blocked，准备继续争夺
            //5.this对象锁是非公平锁

            synchronized (this) {
                //判断余额是否够
                if (money < 1000) {
                    System.out.println("余额不足");
                    break;
                }
                money -= 1000;
                System.out.println(Thread.currentThread().getName() + " 取出了1000块 " + "当前余额" + money);
            }
            //休眠1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
binnnnnnn_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程嵌套_Java多线程进阶
weixin_36002897的博客
02-16 4197
需要理解锁是什么意思?首先是发生在多线程的情况下;线程a,线程b,共享资源share例如,share的资源一次只能被一个对象操作,这时候需要一个东西来标识(也叫监视器)出来表明该资源已经有人(指的是线程)在使用了,请还要使用的人(指的是线程)进入等待(线程等待池/队列);怎么实现呢?synchronized关键字,配合一个唯一的东西,可以是类.class,也可以是对象本身;但注意的是必须是一个引用...
java多线程查询_java多线程查询
weixin_33370255的博客
02-20 3386
标签：由于最近工作遇到性能问题，尝试研究用多线程来实现，结果速度快了好几倍下面是多线程查询的部分代码，提供给大家参考下：线程类：带返回值的类要实现Callable接口，具体业务逻辑没有实现，只是写了个空方法在里面package com.sanfy.demo.thread;import java.util.List;import java.util.Map;import java.util.conc...
如何查看自己电脑是几核的？
战士小小白的博客
11-27 2万+
第一步：打开任务管理器 第二步：点击性能-->打开资源监视器 第三步：点击CPU-->下拉滚动条 第四步：查看CPU——8核
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java_线程—经典的例子：售票
不求重复造轮子，但必须要知道轮子是怎么造的。
09-02 1998
在多线程中，有一个经典的例子：售票 售票很常见，公园，车站，电影院，都有售票系统，通常这些售票的地方，都开放着不止一个售票窗口。这就涉及到了多线程的概念了。 接下来看看这个例子： 既然线程有两种方式，我们就分别看看这两种方式写出来的程序和运行之后的结果是咋样的？ 先来看看继承Thread的方式：
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 16万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
java中线程设置超时_线程执行设置超时时间
weixin_32155269的博客
02-27 5480
import java.util.concurrent.*;/*** 记录，备忘……* 线程执行设置超时时间*/public class Main2 {// 定义线程池，推荐手动创建线程池： https://blog.csdn.net/LLLLLiSHI/article/details/88057655private static ExecutorService pool = Execu...
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
java dump 线程_JVM 线程dump 导出和分析
weixin_30714077的博客
02-16 2254
前言线程dump是非常有用的诊断java应用问题的工具，每一个java虚拟机都有及时生成显示所有线程在某一点状态的线程dump的能力。虽然各个java虚拟机线程dump打印输出格式上略微有一些不同，但是线程dump出来的信息包含线程基本信息；线程的运行状态、标识和调用的堆栈；调用的堆栈包含完整的类名，所执行的方法，如果可能的话还有源代码的行数。JVM中的许多问题都可以使用线程dump文件来进行诊断...
java怎么销毁线程_线程 ： Java中终止（销毁）线程的方法
weixin_42533120的博客
02-12 2475
结束线程有以下三种方法：(1)设置退出标志，使线程正常退出，也就是当run()方法完成后线程终止(2)使用interrupt()方法中断线程(3)使用stop方法强行终止线程(不推荐使用，Thread.stop, Thread.suspend, Thread.resume 和Runtime.runFinalizersOnExit 这些终止线程运行的方法已经被废弃，使用它们是极端不安全的！)stop...
java_type_train.rar_java 多线程_java 打字 程序_train_线程
09-23
1. **线程状态**：Java线程有新建、可运行、运行、等待、阻塞和死亡等六种状态，理解这些状态及其转换对于调试和优化多线程程序至关重要。 2. **同步机制**：包括synchronized关键字、wait()、notify()和notifyAll()...
Java__线程.mp4
07-09
Java__线程.mp4
java_Thread.rar_java 多线程_java多线程
09-21
Java多线程是Java编程中的重要概念，它允许程序同时执行多个任务，从而提高系统资源的利用率和程序的响应速度。在Java中，通过实现Runnable接口或者继承Thread类可以创建并运行多线程。本资料"java_Thread.rar"提供...
seaworld_java线程_java_doingw91_
10-03
在“seaworld_java线程_java_doingw91_”这个项目中，我们主要探讨的是如何使用Java Swing构建一个海底世界的模拟应用，并且涉及到Java线程的运用。这是一个很好的实践示例，可以帮助我们深入理解Java图形用户界面...
java_movestar.rar_j2se_线程控制
09-24
在这个名为"java_movestar.rar_j2se_线程控制"的压缩包中，我们很显然会探讨如何在J2SE环境中使用线程来控制程序的执行，特别是针对一个有趣的实例——在屏幕上画出移动的星星。 线程在计算机科学中是并发执行的...
golang 接口
m0_70982551的博客
07-24 813
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 367
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
【Java算法专场】二分查找(下）
最新发布
zhyhgx的博客
07-27 415
本道题是要在一个从0~n-1的数组中找缺失的数，我们可以采用哈希表来解决，但此时时空复杂度达到了O(n),这是一个有序的数组，我们可以采用二分查找来解决，使时间复杂度达到O(logn).我们可以发现，每个数组的下标和其元素是相同的，那么我们可以通过判断下标和元素的大小，来确定缺失值的位置。3.mid=4+(5-4)/2=4,nums[mid]=5
springboot之自动装配
weixin_50153914的博客
07-23 504
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
java 优化线程_JAVA线程优化
05-27
2. 合理设置线程的优先级：Java线程有10个优先级，线程的优先级越高，CPU分配给它的时间就越多。但是，线程的优先级并不是越高越好，合理的设置线程优先级可以充分利用CPU资源，避免线程饥饿。 3. 减少线程上下文...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值