AI 助理
备案控制台
开发者社区 安全 文章 正文

Java多线程

2022-05-30 124
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java多线程

1. 实现多线程

1.1 进程和线程

  • 进程：是正在运行的程序
    是系统进行资源分配和调用的独立单位
    每一个进程都有它自己的内存空间和系统资源
  • 线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径，则称为单线程程序

多线程：一个进程如果有多条执行路径，则称为多线程程序


1.2 实现多线程方式一：继承Thread类

方法介绍

28.png

实现步骤

  • 定义一个类MyThread继承Thread类
  • 在MyThread类中重写run()方法
  • 创建MyThread类的对象
  • 启动线程


代码演示

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
//        my1.run();
//        my2.run();
        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
    }
}

两个小问题

  • 为什么要重写run()方法？
    因为run()是用来封装被线程执行的代码
  • run()方法和start()方法的区别？
    run()：封装线程执行的代码，直接调用，相当于普通方法的调用
    start()：启动线程；然后由JVM调用此线程的run()方法


1.3 设置和获取线程名称

方法介绍

29.png

代码演示

public class MyThread extends Thread {
    public MyThread() {}
    public MyThread(String name) {
        super(name);
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();
        //void setName(String name)：将此线程的名称更改为等于参数 name
        my1.setName("高铁");
        my2.setName("飞机");
        //Thread(String name)
        MyThread my1 = new MyThread("高铁");
        MyThread my2 = new MyThread("飞机");
        my1.start();
        my2.start();
        //static Thread currentThread() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

1.4 线程优先级

线程调度

  • 两种调度方式
  • 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  • 抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
  • Java使用的是抢占式调度模型
  • 随机性
    假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的


优先级相关方法

30.png

代码演示

public class ThreadPriority extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();
        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");
        //public final int getPriority()：返回此线程的优先级
        System.out.println(tp1.getPriority()); //5
        System.out.println(tp2.getPriority()); //5
        System.out.println(tp3.getPriority()); //5
        //public final void setPriority(int newPriority)：更改此线程的优先级
//        tp1.setPriority(10000); //IllegalArgumentException
        System.out.println(Thread.MAX_PRIORITY); //10
        System.out.println(Thread.MIN_PRIORITY); //1
        System.out.println(Thread.NORM_PRIORITY); //5
        //设置正确的优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);
        tp1.start();
        tp2.start();
        tp3.start();
    }
}


1.5 线程控制

相关方法

31.png


代码演示

sleep演示：
public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();
        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");
        ts1.start();
        ts2.start();
        ts3.start();
    }
}
Join演示：
public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();
        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");
        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}
Daemon演示：
public class ThreadDaemon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}
public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();
        td1.setName("关羽");
        td2.setName("张飞");
        //设置主线程为刘备
        Thread.currentThread().setName("刘备");
        //设置守护线程
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();
        for(int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}


1.6 线程的生命周期

线程一共有五种状态，线程在各种状态之间转换。

32.png

1.7 实现多线程方式二：实现Runnable接口

  • Thread构造方法
    33.png
  • 实现步骤
  • 定义一个类MyRunnable实现Runnable接口
  • 在MyRunnable类中重写run()方法
  • 创建MyRunnable类的对象
  • 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
  • 启动线程
  • 代码演示
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();
        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        //Thread(Runnable target, String name)
        Thread t1 = new Thread(my,"高铁");
        Thread t2 = new Thread(my,"飞机");
        //启动线程
        t1.start();
        t2.start();
    }
}

多线程的实现方案有两种


继承Thread类

实现Runnable接口

相比继承Thread类，实现Runnable接口的好处


避免了Java单继承的局限性


适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想


2. 线程同步

2.1 卖票

  • 案例需求
    某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
  • 实现步骤


定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;


在SellTicket类中重写run()方法实现卖票，代码步骤如下


判断票数大于0，就卖票，并告知是哪个窗口卖的


卖了票之后，总票数要减1


票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行


定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下


创建SellTicket类的对象


创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称


启动线程


代码实现

public class SellTicket implements Runnable {
    private int tickets = 100;
    //在SellTicket类中重写run()方法实现卖票，代码步骤如下
    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                tickets--;
            }
        }
    }
}
public class SellTicketDemo {
    public static void main(String[] args) {
        //创建SellTicket类的对象
        SellTicket st = new SellTicket();
        //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
        Thread t1 = new Thread(st,"窗口1");
        Thread t2 = new Thread(st,"窗口2");
        Thread t3 = new Thread(st,"窗口3");
        //启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

执行结果

41.png


2.2 卖票案例的问题

  • 卖票出现了问题
  • 相同的票出现了多次
  • 出现了负数的票
  • 问题产生原因
    线程执行的随机性导致的
public class SellTicket implements Runnable {
    private int tickets = 100;
    @Override
    public void run() {
        //相同的票出现了多次
//        while (true) {
//            //tickets = 100;
//            //t1,t2,t3
//            //假设t1线程抢到CPU的执行权
//            if (tickets > 0) {
//                //通过sleep()方法来模拟出票时间
//                try {
//                    Thread.sleep(100);
//                    //t1线程休息100毫秒
//                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
//                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                //假设线程按照顺序醒过来
//                //t1抢到CPU的执行权，在控制台输出：窗口1正在出售第100张票
//                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//                //t2抢到CPU的执行权，在控制台输出：窗口2正在出售第100张票
//                //t3抢到CPU的执行权，在控制台输出：窗口3正在出售第100张票
//                tickets--;
//                //如果这三个线程还是按照顺序来，这里就执行了3次--的操作，最终票就变成了97
//            }
//        }
        //出现了负数的票
        while (true) {
            //tickets = 1;
            //t1,t2,t3
            //假设t1线程抢到CPU的执行权
            if (tickets > 0) {
                //通过sleep()方法来模拟出票时间
                try {
                    Thread.sleep(100);
                    //t1线程休息100毫秒
                    //t2线程抢到了CPU的执行权，t2线程就开始执行，执行到这里的时候，t2线程休息100毫秒
                    //t3线程抢到了CPU的执行权，t3线程就开始执行，执行到这里的时候，t3线程休息100毫秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //假设线程按照顺序醒过来
                //t1抢到了CPU的执行权，在控制台输出：窗口1正在出售第1张票
                //假设t1继续拥有CPU的执行权，就会执行tickets--;操作，tickets = 0;
                //t2抢到了CPU的执行权，在控制台输出：窗口1正在出售第0张票
                //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -1;
                //t3抢到了CPU的执行权，在控制台输出：窗口3正在出售第-1张票
                //假设t2继续拥有CPU的执行权，就会执行tickets--;操作，tickets = -2;
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                tickets--;
            }
        }
    }
}


2.3 同步代码块解决数据安全问题

  • 安全问题出现的条件
  • 是多线程环境
  • 有共享数据
  • 有多条语句操作共享数据
  • 如何解决多线程安全问题呢?
  • 基本思想：让程序没有安全问题的环境
  • 怎么实现呢?
  • 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
  • Java提供了同步代码块的方式来解决
  • 同步代码块格式：
synchronized(任意对象) { 
  多条语句操作共享数据的代码
  • synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
  • 同步的好处和弊端
  • 好处：解决了多线程的数据安全问题
  • 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
  • 代码演示
  public class SellTicket implements Runnable {
      private int tickets = 100;
      private Object obj = new Object();
      @Override
      public void run() {
          while (true) {
              //tickets = 100;
              //t1,t2,t3
              //假设t1抢到了CPU的执行权
              //假设t2抢到了CPU的执行权
              synchronized (obj) {
                  //t1进来后，就会把这段代码给锁起来
                  if (tickets > 0) {
                      try {
                          Thread.sleep(100);
                          //t1休息100毫秒
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      //窗口1正在出售第100张票
                      System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                      tickets--; //tickets = 99;
                  }
              }
              //t1出来了，这段代码的锁就被释放了
          }
      }
  }
  public class SellTicketDemo {
      public static void main(String[] args) {
          SellTicket st = new SellTicket();
          Thread t1 = new Thread(st, "窗口1");
          Thread t2 = new Thread(st, "窗口2");
          Thread t3 = new Thread(st, "窗口3");
          t1.start();
          t2.start();
          t3.start();
      }
  }

2.4 同步方法解决数据安全问题

  • 同步方法的格式
    同步方法：就是把synchronized关键字加到方法上
修饰符 synchronized 返回值类型 方法名(方法参数) { 
  方法体；
}
  • 同步方法的锁对象是什么呢?
    this
  • 静态同步方法
    同步静态方法：就是把synchronized关键字加到静态方法上
修饰符 static synchronized 返回值类型 方法名(方法参数) { 
  方法体；
}
  • 同步静态方法的锁对象是什么呢?
    类名.class
  • 代码演示
  public class SellTicket implements Runnable {
      private static int tickets = 100;
      private Object obj = new Object();
      private int x = 0;
      @Override
      public void run() {
          while (true) {
              if (x % 2 == 0) {
                  synchronized (SellTicket.class) {
                      if (tickets > 0) {
                          try {
                              Thread.sleep(100);
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                          System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                          tickets--;
                      }
                  }
              } else {
                  sellTicket();
              }
              x++;
          }
      }
      private static synchronized void sellTicket() {
          if (tickets > 0) {
              try {
                  Thread.sleep(100);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
              tickets--;
          }
      }
  }

2.5 线程安全的类

  • StringBuffer
  • 线程安全，可变的字符序列
  • 从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步
  • Vector
  • 从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector
  • Hashtable


该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值

从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable



2.6 Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock


Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化


ReentrantLock构造方法

41.png

加锁解锁方法

42.png

代码演示

  public class SellTicket implements Runnable {
      private int tickets = 100;
      private Lock lock = new ReentrantLock();
      @Override
      public void run() {
          while (true) {
              try {
                  lock.lock();
                  if (tickets > 0) {
                      try {
                          Thread.sleep(100);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                      tickets--;
                  }
              } finally {
                  lock.unlock();
              }
          }
      }
  }
  public class SellTicketDemo {
      public static void main(String[] args) {
          SellTicket st = new SellTicket();
          Thread t1 = new Thread(st, "窗口1");
          Thread t2 = new Thread(st, "窗口2");
          Thread t3 = new Thread(st, "窗口3");
          t1.start();
          t2.start();
          t3.start();
      }
  }


3. 生产者消费者

3.1 生产者和消费者模式概述

概述


生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。


所谓生产者消费者问题，实际上主要是包含了两类线程：


一类是生产者线程用于生产数据


一类是消费者线程用于消费数据


为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库


生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为


消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

44.png

Object类的等待和唤醒方法


45.png


3.2 生产者和消费者案例

  • 案例需求

生产者消费者案例中包含的类：


奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作


生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作


消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作


测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下


①创建奶箱对象，这是共享数据区域


②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作


③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作


④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递


⑤启动线程


代码实现

public class Box {
    //定义一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;
    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk) {
        //如果有牛奶，等待消费
        if(state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，就生产牛奶
        this.milk = milk;
        System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");
        //生产完毕之后，修改奶箱状态
        state = true;
        //唤醒其他等待的线程
        notifyAll();
    }
    public synchronized void get() {
        //如果没有牛奶，等待生产
        if(!state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第" + this.milk + "瓶奶");
        //消费完毕之后，修改奶箱状态
        state = false;
        //唤醒其他等待的线程
        notifyAll();
    }
}
public class Producer implements Runnable {
    private Box b;
    public Producer(Box b) {
        this.b = b;
    }
    @Override
    public void run() {
        for(int i=1; i<=30; i++) {
            b.put(i);
        }
    }
}
public class Customer implements Runnable {
    private Box b;
    public Customer(Box b) {
        this.b = b;
    }
    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}
public class BoxDemo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
        Box b = new Box();
        //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
        //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        Customer c = new Customer(b);
        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        //启动线程
        t1.start();
        t2.start();
    }
}


文章标签：
Java
安全
调度
存储
关键词：
Java多线程
Java线程
1474418023075726
目录
相关文章
flzjkl
|
14天前
|
存储 监控 Java
【Java并发】【线程池】带你从0-1入门线程池
欢迎来到我的技术博客！我是一名热爱编程的开发者，梦想是编写高端CRUD应用。2025年我正在沉淀中，博客更新速度加快，期待与你一起成长。 线程池是一种复用线程资源的机制，通过预先创建一定数量的线程并管理其生命周期，避免频繁创建/销毁线程带来的性能开销。它解决了线程创建成本高、资源耗尽风险、响应速度慢和任务执行缺乏管理等问题。
flzjkl
136 60
【Java并发】【线程池】带你从0-1入门线程池
Bluening
|
3天前
|
存储 网络协议 安全
Java网络编程，多线程，IO流综合小项目一一ChatBoxes
**项目介绍**：本项目实现了一个基于TCP协议的C/S架构控制台聊天室，支持局域网内多客户端同时聊天。用户需注册并登录，用户名唯一，密码格式为字母开头加纯数字。登录后可实时聊天，服务端负责验证用户信息并转发消息。 **项目亮点**： - **C/S架构**：客户端与服务端通过TCP连接通信。 - **多线程**：采用多线程处理多个客户端的并发请求，确保实时交互。 - **IO流**：使用BufferedReader和BufferedWriter进行数据传输，确保高效稳定的通信。 - **线程安全**：通过同步代码块和锁机制保证共享数据的安全性。
Bluening
50 23
flzjkl
|
10天前
|
Java 调度
【源码】【Java并发】【线程池】邀请您从0-1阅读ThreadPoolExecutor源码
当我们创建一个`ThreadPoolExecutor`的时候，你是否会好奇🤔，它到底发生了什么？比如：我传的拒绝策略、线程工厂是啥时候被使用的？ 核心线程数是个啥？最大线程数和它又有什么关系？线程池，它是怎么调度，我们传入的线程？...不要着急，小手手点上关注、点赞、收藏。主播马上从源码的角度带你们探索神秘线程池的世界...
flzjkl
75 0
【源码】【Java并发】【线程池】邀请您从0-1阅读ThreadPoolExecutor源码
软件求生
|
25天前
|
Java 程序员 开发者
Java社招面试题：一个线程运行时发生异常会怎样？
大家好，我是小米。今天分享一个经典的 Java 面试题：线程运行时发生异常，程序会怎样处理？此问题考察 Java 线程和异常处理机制的理解。线程发生异常，默认会导致线程终止，但可以通过 try-catch 捕获并处理，避免影响其他线程。未捕获的异常可通过 Thread.UncaughtExceptionHandler 处理。线程池中的异常会被自动处理，不影响任务执行。希望这篇文章能帮助你深入理解 Java 线程异常处理机制，为面试做好准备。如果你觉得有帮助，欢迎收藏、转发！
软件求生
98 14
软件求生
|
1月前
|
安全 Java 程序员
Java 面试必问！线程构造方法和静态块的执行线程到底是谁？
大家好，我是小米。今天聊聊Java多线程面试题：线程类的构造方法和静态块是由哪个线程调用的？构造方法由创建线程实例的主线程调用，静态块在类加载时由主线程调用。理解这些细节有助于掌握Java多线程机制。下期再见！ 简介： 本文通过一个常见的Java多线程面试题，详细讲解了线程类的构造方法和静态块是由哪个线程调用的。构造方法由创建线程实例的主线程调用，静态块在类加载时由主线程调用。理解这些细节对掌握Java多线程编程至关重要。
软件求生
54 13
心疼你的一切
|
1月前
|
安全 Java 开发者
【JAVA】封装多线程原理
Java 中的多线程封装旨在简化使用、提高安全性和增强可维护性。通过抽象和隐藏底层细节，提供简洁接口。常见封装方式包括基于 Runnable 和 Callable 接口的任务封装，以及线程池的封装。Runnable 适用于无返回值任务，Callable 支持有返回值任务。线程池（如 ExecutorService）则用于管理和复用线程，减少性能开销。示例代码展示了如何实现这些封装，使多线程编程更加高效和安全。
心疼你的一切
59 8
蓝易云
|
2月前
|
监控 Java
java异步判断线程池所有任务是否执行完
通过上述步骤，您可以在Java中实现异步判断线程池所有任务是否执行完毕。这种方法使用了 `CompletionService`来监控任务的完成情况，并通过一个独立线程异步检查所有任务的执行状态。这种设计不仅简洁高效，还能确保在大量任务处理时程序的稳定性和可维护性。希望本文能为您的开发工作提供实用的指导和帮助。
蓝易云
123 17
大数据文摘
|
3月前
|
Java
Java—多线程实现生产消费者
本文介绍了多线程实现生产消费者模式的三个版本。Version1包含四个类：`Producer`（生产者）、`Consumer`（消费者）、`Resource`（公共资源）和`TestMain`（测试类）。通过`synchronized`和`wait/notify`机制控制线程同步，但存在多个生产者或消费者时可能出现多次生产和消费的问题。 Version2将`if`改为`while`，解决了多次生产和消费的问题，但仍可能因`notify()`随机唤醒线程而导致死锁。因此，引入了`notifyAll()`来唤醒所有等待线程，但这会带来性能问题。
大数据文摘
91 1
Java—多线程实现生产消费者
游客r2tgrg3ez7yzc
|
2月前
|
缓存 安全 算法
Java 多线程 面试题
Java 多线程 相关基础面试题
游客r2tgrg3ez7yzc
65 2
2G冲浪词条
|
3月前
|
安全 Java Kotlin
Java多线程——synchronized、volatile 保障可见性
Java多线程中，`synchronized` 和 `volatile` 关键字用于保障可见性。`synchronized` 保证原子性、可见性和有序性，通过锁机制确保线程安全；`volatile` 仅保证可见性和有序性，不保证原子性。代码示例展示了如何使用 `synchronized` 和 `volatile` 解决主线程无法感知子线程修改共享变量的问题。总结：`volatile` 确保不同线程对共享变量操作的可见性，使一个线程修改后，其他线程能立即看到最新值。
2G冲浪词条
77 7

热门文章

最新文章

  • 1
    【AI程序员】通义灵码 AI 程序员全面上线JAVA使用体验
  • 2
    接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
  • 3
    从理论到实践：使用JAVA实现RAG、Agent、微调等六种常见大模型定制策略
  • 4
    一天成为Java开发高手：用飞算JavaAI实现十倍提效
  • 5
    【Java并发】【线程池】带你从0-1入门线程池
  • 6
    Java也能快速搭建AI应用？一文带你玩转Spring AI可落地性
  • 7
    Java+机器学习基础：打造AI学习基础
  • 8
    java语言后台管理若依框架-登录提示404-接口异常-系统接口404异常如何处理-登录验证码不显示prod-api/captchaImage 404 (Not Found) 如何处理-解决方案优雅草卓伊凡
  • 9
    Java社招面试题：一个线程运行时发生异常会怎样？
  • 10
    java语言后台管理ruoyi后台管理框架-登录提示“无效的会话，或者会话已过期，请重新登录。”-扩展知识数据库中密码加密的方法-问题如何解决-以及如何重置若依后台管理框架admin密码-优雅草卓伊凡
  • 1
    Java中的多线程编程：概念、实现及性能优化
    102
  • 2
    深入理解Java并发编程：线程池的原理与实践
    89
  • 3
    开发与运维命令问题之使用jstack命令查看Java进程的线程栈如何解决
    93
  • 4
    软件架构一致性问题之通过软件供应链管理提升研发体验如何解决
    70
  • 5
    数据库问题之使用jmap命令获取Java堆信息如何解决
    51
  • 6
    Java入门软件及基础语法
    54
  • 7
    Java安装
    45
  • 8
    开发与运维引用问题之软引用又在Java特点如何解决
    61
  • 9
    如何在Java中使用Socket编程实现TCP连接?
    376
  • 10
    Java 并发编程之深入理解线程池
    59

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    通义万相2.1视频/图像模型新升级！可在阿里云百炼直接体验