Java-多线程

最新推荐文章于 2025-04-27 22:48:25 发布
最新推荐文章于 2025-04-27 22:48:25 发布
阅读量65 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Y717310/article/details/132147352
版权

线程简介

程序：指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念

进程：执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位

线程：线程就是独立的执行路径，也是CPU调度和执行的单位，通常一个进程可以包含多个线程，当然一个进程至少有一个线程，不然没有意义

注意：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

线程创建

三种创建方式：

1-Thread类

  • 自定义线程类继承Thread类
  • 重写run()方法，编写线程执行体
  • 创建线程对象，调用start()方法启动线程

代码：

//创建线程方法一：继承Thread类，重写run()方法，调用start开启线程
//线程执行不是交替进行的，是有cpu调用
public class ThreadDemo extends Thread{
    //重写run方法
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码---"+i);
        }
    }

    public static void main(String[] args) {
        //创建线程对象
        ThreadDemo demo = new ThreadDemo();
        //调用start方法
        demo.start();
        for (int i = 0; i < 500; i++) {
            System.out.println("123----"+i);
        }
    }
}

继承Thread类：

  • 子类继承Thread类具备多线程能力
  • 启动线程：子类对象.start()
  • 不建议使用：避免OOP单继承局限性

2-Runnable接口

  • 定义myrunnable类实现Runnable接口
  • 实现run()方法，编写线程执行体
  • 创建线程对象，调用start方法启动线程

代码：

//创建线程方式二：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class MyRunnable implements Runnable{
    //重写run方法
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("123---"+i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        MyRunnable myRunnable = new MyRunnable();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        Thread thread = new Thread(myRunnable);
        thread.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("asd---"+i);
        }
    }
}

实现Runnable接口：

  • 实现接口Runnable具备多线程能力
  • 启动线程：传入目标对象+Thread对象.start()
  • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

练习案例：模拟龟兔赛跑

//龟兔赛跑案例
public class TestThread1 implements Runnable{
    //胜利者
    private static String winner;
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {

            //模拟兔子睡觉
            if (Thread.currentThread().getName().equals("兔子")&&i%10==0){
                try{
                    Thread.sleep(10);
                }catch (InterruptedException e){
                    System.out.println(e);
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(i);
            if (flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps){
        //判断是否有胜利者
        if (winner!=null){
            return true;
        }else {
            if (steps>=100){
                winner=Thread.currentThread().getName();
                System.out.println("winner is "+winner);
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {

        TestThread1 thread1 = new TestThread1();
        new Thread(thread1,"兔子").start();
        new Thread(thread1,"乌龟").start();
    }
}

3-Callable接口

  • 实现Callable接口，需要返回值类型
  • 重写call方法，需要抛出异常
  • 创建目标对象
  • 创建执行服务：ExecutorService  ser = Executors.newFixedThreadPool(1);
  • 提交执行：Future<Boolean>result1 = ser.submit(t1);
  • 获取结果：boolean r1 = result1.get();
  • 关闭服务：ser.shutdownNow();

代码：

//线程创建方式三：Callable接口
public class Demo1 implements Callable<Boolean>{

    @Override
    public Boolean call() {
        for (int i = 0; i < 20; i++) {
            System.out.println("123--"+i);
        }
        return true ;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Demo1 testThread = new Demo1();
      //创建服务
        ExecutorService ser = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> R1 =  ser.submit(testThread);
        //获取结果
        boolean re1 = R1.get();
        ser.shutdownNow();
    }

静态代理

  • 帮助真实对象做一些事情
  • 静态对象和真实对象都要实现同一个接口
  • 代理对象要代理真实对象

好处：

  1. 代理对象可以做很多真实对象做不了的事情
  2. 真实对象可以专注做自己的事情

案例代码：

public class TestMarry {
    public static void main(String[] args) {
        weddingCompany wedding1= new weddingCompany(new You());
        wedding1.happyMarry();
    }
}
//定义一个接口
interface Marry{
    void happyMarry();
}
//定义真实对象类，做的事
class You implements Marry{
    @Override
    public void happyMarry() {
        System.out.println("结婚了高兴！");
    }
}
//代理角色，帮你做这件事
class weddingCompany implements Marry{
    //代理谁
    private Marry target;
    public weddingCompany(Marry target){
        this.target=target;
    }

    @Override
    public void happyMarry() {
        before();
        this.target.happyMarry();//这就是真实对象
        after();
    }

    private void after() {
        System.out.println("完婚，收尾款");
    }

    private void before() {
        System.out.println("婚前，布置现场");
    }
}

Lamda表达式

lamda表达式的意义：

  • 避免匿名内部类定义过多
  • 可以让你的代码看起来很简洁
  • 去掉了一推没有意义的代码，只留下核心的逻辑

函数式接口：

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

public interface Runnable{
     public abstract void run(); 
}

Lamda表达式简化：

  1. 简化参数类型：多个参数时需要全部去掉参数类型
  2. 简化括号：单个参数时可以简化
  3. 简化代码块：代码坏内容为一行时可以简化

代码：

public class TestLamda {
    //3.静态局部类
    static class LamLike1 implements Lamda{
        @Override
        public void like(int a) {
            System.out.println("Lamda-->"+a);
        }
    }
    public static void main(String[] args) {
        Lamda lamLike = new LamLike();
        lamLike.like(1);

        lamLike = new LamLike1();
        lamLike.like(2);

        //4.局部内部类
        class LamLike2 implements Lamda{

            @Override
            public void like(int a) {
                System.out.println("Lamda-->"+a);
            }
        }
        lamLike = new LamLike2();
        lamLike.like(3);

        //5匿名内部类，没有类的名称，必须借助接口或父类
        lamLike = new LamLike(){
            @Override
            public void like(int a) {
                System.out.println("Lamda-->"+a);
            }
        };
        lamLike.like(4);

        //6.lamda表达式
        lamLike = (int a)->{
            System.out.println("Lamda-->"+a);
        };
        lamLike.like(5);
        //7.简化数据类型
        lamLike = (a)->{
            System.out.println("Lamda-->"+a);
        };
        lamLike.like(6);
        //8.简化括号
        lamLike = a->{
            System.out.println("Lamda-->"+a);
        };
        lamLike.like(7);
        //9.简化代码块
        lamLike = a-> System.out.println("Lamda-->"+a);

        lamLike.like(8);
    }
}
//1.定义一个函数式接口Lamda
interface Lamda{
    void like(int a);
}
//2.定义一个实现类Lamlike
class LamLike implements Lamda{

    @Override
    public void like(int a) {
        System.out.println("Lamda-->"+a);
    }
}

线程状态

  1. 创建状态：线程对象一旦创建就进入了创建状态
  2. 就绪状态：当调用start()方法，线程就进入就绪状态，但不意味着立即调度执行
  3. 运行状态：进入运行状态，线程才真正的执行线程体的代码块
  4. 阻塞状态：当调用sleep、wait或同步锁定时，线程进入阻塞状态；就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行
  5. 死亡状态：线程中断或者结束，一旦进入死亡状态，就不能再次启动

线程方法：

  • setPriority(int newPriority)：更改线程优先级
  • static void sleep(long mills)：在指定的毫秒数内让当前正在执行的线程体休眠
  • void join()：暂停当前正在执行的线程对象，并执行其他线程
  • static void yield()：等待该线程终止
  • void interrupt()：中断线程，尽量不用
  • boolean isAlive()：测试线程是否处于活动状态

线程停止：

  1. 建议线程正常停止，利用次数，不建议死循环
  2. 建议使用标志位，设置一个标志位
  3. 不建议使用stop或destroy等过时或者不建议使用的方法
public class TestStop implements Runnable{

    private boolean flag =true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("线程跑了"+i++);
        }
    }
    public void stop(){
        this.flag= false ;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main"+i);
            if (i==900){
                testStop.stop();
                System.out.println("线程停止了");
            }
        }
    }
}

线程休眠：

  • sleep（时间）指定当前线程阻塞的毫秒数
  • sleep存在异常InterruptedException，需要抛出或try--catch
  • sleep时间到达后线程进入就绪状态
  • sleep可以模拟网络延时、倒计时等
  • 每一个对象都有一个锁，sleep不会释放锁

代码：模拟倒计时

//模拟倒计时
public class TestSleep {
    public static void main(String[] args) throws InterruptedException {
        //tenDown();
        //打印系统当前的时间
        //获取系统当前时间
        Date time = new Date(System.currentTimeMillis());
        while (true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(time));
            //更新当前时间
            time = new Date(System.currentTimeMillis());
        }
    }

    //倒计时方法
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if (num<=0){
                break;
            }
        }

    }
}

线程礼让：但是不一定成功，看cpu心情

线程插队：Join方法

代码：

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程VIP来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        for (int i = 0; i < 200; i++) {
            if (i==100){
                thread.join();
            }
            System.out.println("主线程"+i);
        }


    }
}

线程状态观测：Thread.State

代码：

//查看线程的状态
public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread =new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println(e);
                }

            }
            System.out.println("=======");
        });



        //观察线程状态
        Thread.State state = thread.getState();
        System.out.println(state);//new
        //启动线程后的状态
        thread.start();
        state = thread.getState();
        System.out.println(state);//run

        //只要线程不终止就一直输出状态
        while (state!= Thread.State.TERMINATED){
            Thread.sleep(100);
            //更新线程状态
            state = thread.getState();
            //状态输出
            System.out.println(state);
        }
    }
}

线程优先级：权重1-10

  • 设置优先级超过范围就会报错
  • 优先级低的只是意味着被调用的概率低
  • 默认的优先级为5

代码：

//测试线程优先级
public class TestPriority {
    public static void main(String[] args) {
        //获取主线程的优先级
        System.out.println(Thread.currentThread().getName()+"==="+Thread.currentThread().getPriority());

        Priority priority = new Priority();
        Thread thread = new Thread(priority);
        Thread thread1 = new Thread(priority);
        Thread thread2 = new Thread(priority);
        Thread thread3 = new Thread(priority);
        Thread thread4 = new Thread(priority);
        Thread thread5 = new Thread(priority);
        thread.start();//默认优先级
        //线程优先级先设置，再启动
        thread1.setPriority(1);
        thread1.start();

        thread2.setPriority(4);
        thread2.start();

        thread3.setPriority(10);
        thread3.start();

        thread4.setPriority(2);
        thread4.start();
        thread5.setPriority(8);
        thread5.start();


    }
}

class Priority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"==="+Thread.currentThread().getPriority());
    }
}

守护线程：

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 后台记录操作日志、监控内存、垃圾回收等就是守护线程

代码：

//测试守护线程
public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();
        //默认为false
        Thread thread = new  Thread(god);
        thread.setDaemon(true);
        thread.start();

        new Thread(you).start();
    }
}

//守护者
class God implements Runnable{
    @Override
    public void run() {
        //让守护者一致跑着
        while (true){
            System.out.println("一直守着你");
        }
    }
}

//用户
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("活完一生");
        }
        System.out.println("==结束==");
    }
}

线程同步

并发：同一个对象被多个线程同时操作

线程同步：就是一个等待机制，形成队列+锁保证安全性

同步方法：synchronized void 方法名（）

  • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

同步块 synchronized (Obj){}:

  • Obj称为同步监视器
  • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器

同步监视器的执行过程：

  1. 线程1访问，锁定同步监视器，执行其中代码
  2. 线程2访问，发现同步监视器被锁定，无法访问
  3. 线程1访问完毕，解锁同步监视器
  4. 线程2访问，发现同步监视器没有锁，然后锁定并访问

示例代码：

//线程不安全的集合
//如果只用了synchronized同步快，没有使用sleep，也可能出现数据紊乱
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 5000; i++) {
            new Thread(()->{
                //同步代码块
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
              }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());//输出：5000
    }
}

JUC安全类型集合：

代码测试：

//测试JUC安全集合
public class TestJUC {
    public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<String>list=new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

死锁：

多个线程相互抱着对方需要的资源，然后形成僵持

产生死锁的四个必要条件：

  1. 互斥条件：一个资源每次只能被一个进程使用
  2. 请求和保持条件：一个进程因请求资源而阻塞时，对方已获得的资源保持不放
  3. 不剥夺条件：进程已有的资源，在未完成之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

死锁避免方法:

上面列出死锁的四个必要条件，我们只要想办法破其中的任意一个或多个条件就可以避免死锁发生

Lock显示锁

测试代码：

//测试lock
public class TestLock {
    public static void main(String[] args) {
        TestLock1 testLock1= new TestLock1();

        new Thread(testLock1).start();
        new Thread(testLock1).start();
        new Thread(testLock1).start();
    }
}

class TestLock1 implements Runnable{
    int nums = 10;
    //定义lock锁
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();//加锁
                if (nums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(nums--);
                } else {
                    break;
                }
            }finally {
                lock.unlock();//解锁
            }
        }
    }
}

线程协作

生产者：生产者生产产品等待消费者消费

消费者：消费者消费产品，消费完后等待生产者生产

解决方法1：利用缓冲区---管程法

代码示例：

package thread.thread;

//测试生成消费的解决方法：建立缓冲区---管程法
//需要有 生产者、消费者、产品、缓冲区
public class TestPC {
    public static void main(String[] args) {
        BufferArea bufferArea=new BufferArea();
        Productor productor = new Productor(bufferArea);
        CumsComer cumsComer = new CumsComer(bufferArea);

        productor.start();
        cumsComer.start();
    }
}
//生成者
class Productor extends Thread{
    BufferArea bufferArea;
    public Productor( BufferArea bufferArea){
        this.bufferArea=bufferArea;
    }

    //生成
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                bufferArea.push(new Product(i));
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("生成了"+i+"个产品");
        }
    }
}
//消费者
class CumsComer extends Thread{
    BufferArea bufferArea;
    public CumsComer( BufferArea bufferArea){
        this.bufferArea=bufferArea;
    }

    @Override
    public void run(){
        for (int i = 0; i < 100; i++) {
            try {
                System.out.println("消费了"+bufferArea.pop().id+"个产品");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

}
//产品
class Product{
    int id;//产品编号

    public Product(int id) {
        this.id = id;
    }
}
//缓冲区
class BufferArea{
    //缓冲区大小
    Product[] products = new Product[10];
    //数量
    int count=0;
    //生产者放入产品
    public synchronized void push(Product product) throws InterruptedException {
        //如果容器满了，就等待消费者消费
        if (count==products.length){
            //通知消费者消费，生成等待
            this.wait();
        }
        //如果没有满，就放入产品
        products[count]=product;
        count++;
        //通知消费者，可以消费了
        this.notifyAll();

    }

    //消费则消费产品
    public synchronized Product pop() throws InterruptedException {
        //判断能否消费
        if (count==0){
            //等待生成者生产
            this.wait();
        }
        //如果可以消费
        count--;
        Product product=products[count];
        //吃完了，通知生成者生成
        this.notifyAll();
        return product;

    }
}

解决方法2：通过标志位---信号灯法

代码示例：

package thread.thread;

//测试生产者、消费者：信号灯法
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}
//生产者---演员
class Player extends Thread{
    TV tv;
    public Player(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i%2==0){
                this.tv.play("快乐大本营");
            }else {
                this.tv.play("抖音");
            }
        }
    }
}
//消费者---观众
class Watcher extends Thread{
    TV tv;
    public Watcher(TV tv){
        this.tv=tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.view();
        }
    }
}
//产品---节目
class TV{
    //演员表演，观众等待 T
    //观众观看，演员等待 F
    String voice ; //表演的节目
    boolean flag = true ;

    //表演
    public synchronized void play(String voice){
       if (!flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               throw new RuntimeException(e);
           }
       }
        System.out.println("演员表演了："+voice);
        //通知观众观看
        this.notifyAll();
        this.voice=voice;
        this.flag=!this.flag;
    }

    //观看
    public synchronized void view(){
        if (flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("观看了："+voice);
        //通知演员表演
        this.notifyAll();
        this.flag=!this.flag;
    }
}

线程池

线程池好处：

  1. 提高响应速度--减少创建新线程的时间
  2. 降低资源消耗--重复利用线程池中线程，不需要每次创建
  3. 便于线程管理
    1. 核心池的大小
    2. 最大线程数
    3. 线程没有任务时最多保持多长时间会终止

 测试代码：

package thread.thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//线程池
public class TestPool {
    public static void main(String[] args) {
        //创建服务，创建线程池
        //newFixedThreadPool:参数为线程池d大小
        ExecutorService service= Executors.newFixedThreadPool(10);
        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //关闭服务
        service.shutdown();
    }
}
class MyThread implements Runnable{

    @Override
    public void run() {
        
            System.out.println(Thread.currentThread().getName()+i);

    }
}
零度@
关注
Java-多线程线程状态转换图
07-22
多线程线程状态转换图
java-多线程 test
06-11
java-多线程 test
Java - 多线程
了解➔熟悉➔掌握➔精通
03-23 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 引 如果对什么是线程、什么是进程仍存有疑惑，请先Google之，因为这两个概念不在本文讨论的范围之内。 用多线程只有一个目的，那就是更好的利用CPU的资源，因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对，因为反应”多角色”的程序...
JAVA-多线程篇
qq_46489900的博客
06-15 2116
JAVA-多线程一、什么是多线程？二、多线程有什么用？三、多线程常见的问题？四、Java中多线程怎么用？1.创建线程的三种方式1.11.21.3五、保证Java中的线程安全 一、什么是多线程？ 粗略的讲，多线程通常是指在程序运行时，使用CPU的多个线程，由多个线程同时共同完成某些任务，这样的行为叫做多线程处理，这样的方式就是多线程。 二、多线程有什么用？ 在java应用中，最常见的莫过于WEB应用了，而如今的WEB应用大多都有着高并发的需求，需要在很短的事件处理大量的用户请求，因此使用多线程尤为重要。并发可
java-----多线程
qq_44766305的博客
10-21 3076
有了多线程，我们就可以让程序同时做多件事情。
12jmu-Java-07多线程-Thread
ihopeyousuccess的博客
11-30 2352
编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。 功能：输出从0到n-1的整数。 并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即MyThread类的代码/ public class Main { public static void main(String[] args
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
热门推荐
qq_35716689的博客
03-10 25万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
013jmu-Java-07多线程-PrintTask
ihopeyousuccess的博客
11-30 5429
编写PrintTask类实现Runnable接口。 功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。 裁判测试程序： import java.util.Scanner; /这里放置你的答案，即PrintTask类的代码/ public class Main { public static void main(String[] args) { Scann
PTA- jmu-Java-07多线程-交替执行
m0_62565675的博客
12-28 1749
PTA-Java-07多线程-交替执行
Java-多线程的安全问题以及解决方法
qq_58000391的博客
06-05 1266
解决多线程的一些安全问题的方法~~~
6-6 jmu-Java-07多线程-同步访问 (10 分)
m0_54524462的博客
12-02 3769
6-6 jmu-Java-07多线程-同步访问 (10 分) 现已有Account类，拥有 属性: private int balance 方法: 相应的getter方法。 要求为该类编写： void deposit(int money) //存钱，在余额的基础上加上money void withdraw(int money) //取钱，在余额的基础上减去money 注意： 取钱时如果balance<0的时候，会抛出异常。在多线程情况下，如只有一个存钱的线程，但是有多个取钱的线程，很可能会抛出异常。
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java-多线程连接池模型
07-22
多线程连接池模型
14.java-多线程.md
08-18
14.java-多线程
java - juc - 多线程 - 学习 -思维导图
12-16
java - juc - 多线程 - 学习 -思维导图
基于vue框架的电信用户业务管理系统的设计与实现8ly70（程序+源码+数据库+调试部署+开发环境）带论文文档1万字以上，文末可获取，系统界面在最后面。
h2345678的博客
04-25 623
可以控制字体、颜色、间距、布局等视觉表现。[6]师明,曾丹.基于Vue.js和Spring Boot的校招日记系统[J].工业控制计算机,2020,33(01):95-97.[7]胡雅丽.基于Vue.js的“微商城”前端开发设计与实现[J].电子技术与软件工程,2020(20):34-35.[3]张智强，孙福兆，余健等.mysql课程设计案例精编[J].清华大学出版社,2019(8):67-234。[8]李广宏.vue.js前端应用技术分析[J].中国新通信,2019,21(20):115.
MyBatis 类型处理器（TypeHandler）注册与映射机制：JsonListTypeHandler和JsonListTypeHandler注册时机
最新发布
2301_76541209的博客
04-27 584
下面几种机制会让你的最新版本的 MyBatis-Plus starter 会把类路径下所有带这类注解的自动注册进，所以即使你不在里再手动，MyBatis-Plus 启动时也会把它们扫描进来。如果你的实体里写了那 MyBatis 在构建映射的时候会直接 new 这个来处理该字段，不会再走默认的。就算真没有任何自定义 Handler，JDBC 驱动也会把你传进去的字符串（比如你在 Mapper XML 里写#{skills}，skills.toString() 恰好是["a","b"]
Javashop新零售电商系统：构建智能零售生态的终极解决方案
私聊前往站内信：https://i.youkuaiyun.com/#/msg/chat/weixin_44976692
04-23 2164
系统通过统一的后台管理，实现了线上线下商品、库存、订单和会员数据的实时同步，彻底解决了传统零售中数据孤岛的问题。无论是线上小程序商城、实体门店还是第三方平台，所有销售渠道的数据都能在一个系统中集中管理和分析。
【分布式系统中的“瑞士军刀”_ Zookeeper】一、Zookeeper 快速入门和核心概念
qq_58611691的博客
04-25 1203
读完本篇文章相信已经了解了在 CentOS 7 系统中安装和配置 Zookeeper 的方法，以及 Zookeeper 的核心概念，包括 ZNode 节点、Session 会话、Watcher 监听器和 Leader - Follower 模式。同时，还通过实际的命令操作和代码示例，对这些概念有了更直观的认识。Zookeeper 作为分布式协调的重要工具，其功能远不止于此，后续还可以深入学习其在分布式锁、配置管理、服务注册与发现等方面的应用。
Java多线程进度条实现技巧
### 知识点：Java多线程进度条的实现与应用 在现代软件开发中，多线程技术是提升应用程序性能和响应能力的关键技术之一。而进度条作为一种界面元素，可以向用户直观展示长时间运行任务的完成情况，提高用户体验。当...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值