多线程、声明周期、同步机制、死锁、线程池 的完整使用 怼烎@ 2022-11-16 13:38 117阅读 0赞 ### 小坏谈多线程、声明周期、同步机制、死锁、线程池 ### * 一、何为 java 线程之道(线程都包括那些) * * 1、程序(programm) * 2、进程(process) * 3、线程(thread) * 4、线程之道图示 * 5、补充之道、内存结构 * 二、何为 java 并行与并发(之道) * * 1、单核CPU与多核CPU的理解(之道) * 2、并行与并发的理解(之道) * 三、何为 java 创建多线程方式(之道) * * 1、继承Thread类的方式(之道) * * 说明两个问题之道 * 1、实现Runnable接口的方式(之道) * 2、两种方式之道进行对比 * 三、何为 java Thread类中的常用方法(之道) * * 1、Thread常用方法 * 2、线程的优先级 * 3、如何获取和设置当前线程的优先级 * 3、java线程的生命周期 * 四、何为线程同步机制(之道) * * 1、背景 * 2、Java解决方案:同步机制(同步代码块 synchronized )(之道) * 3、解决方法之一(以上两短代码都属于同步代码块) * 4、解决方法之二(同步方法 synchronized ) * 5、解决线程安全问题的方式三:Lock锁 * 6、使用同步机制将单例模式中的懒汉式改写为线程安全的。 * 7、死锁的理解 * 五、何为线程通信(之道) * * 1、线程通信涉及到的三个方法 * 2、说明 * 3、面试题 * 4、小结释放锁的操作 * 5、小结不会释放锁的操作 * 六、JDK5.0新增线程创建的方式 * * 1、新增方式一:实现Callable接口。 --- JDK 5.0新增 * 2、说明 * 3、新增方式二:使用线程池 * 4、说明 * 5、面试题:Java中多线程的创建有几种方式?四种。 # 一、何为 java 线程之道(线程都包括那些) # ## 1、程序(programm) ## * **概念**:为完成特定任务、用某种语言程序写的一组指令的集合。即指一段静态的code。 ## 2、进程(process) ## * **进程概念**:程序的一次执行过程,或是正在运行的一个程序。 * **进程说明**:进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域 ## 3、线程(thread) ## * **线程概念**:进程可进一步细化为线程,是一个程序内部的一条执行路径。 * **线程说明**:线程作为调度和执行的单位,每个线程拥独立的运行栈和程序计数器(pc),线程切换的开销小。 ## 4、线程之道图示 ## ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70] ## 5、补充之道、内存结构 ## ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 1] * 进程可以细化为多个线程。 * 每个线程,拥有自己独立的:栈、程序计数器 * 多个线程,共享同一个进程中的结构:方法区、堆。 # 二、何为 java 并行与并发(之道) # ## 1、单核CPU与多核CPU的理解(之道) ## > 1.单核CPU,其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程的任务。例如:虽然有多车道,但是收费站只有一个工作人员在收费,只有收了费才能通过,那么CPU就好比收费人员。如果某个人不想交钱,那么收费人员可以把他“挂起”(晾着他,等他想通了,准备好了钱,再去收费。)但是因为CPU时间单元特别短,因此感觉不出来。 > 2.如果是多核的话,才能更好的发挥多线程的效率。(现在的服务器都是多核的) > 3.一个Java应用程序java.exe,其实至少三个线程:main()主线程,gc()垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。 ## 2、并行与并发的理解(之道) ## > 并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。 > 并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事 # 三、何为 java 创建多线程方式(之道) # ## 1、继承Thread类的方式(之道) ## 1. 创建个继承 Thread 类的子类 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中 3. 创建Thread类的子类的对象 4. 通过此对象调用start(): ①启动当前线程 ② 调用当前线程的run() ### 说明两个问题之道 ### 问题一:我们启动一个线程,必须调用start(),不能调用run()的方式启动线程。 问题二:如果再启动一个线程,必须重新创建一个Thread子类的对象,调用此对象的start ## 1、实现Runnable接口的方式(之道) ## 1. 创建一个实现了Runnable接口的类 2. 实现类去实现Runnable中的抽象方法:run() 3. 创建实现类的对象 4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象 5. 通过Thread类的对象调用start() ## 2、两种方式之道进行对比 ## * 开发中:优先选择:实现Runnable接口的方式 * 原因: * 1. 实现的方式没类的单继承性的局限性 * 1. 实现的方式更适合来处理多个线程共享数据的情况。 * 联系:public class Thread implements Runnable * 相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。 目前两种方式,要想启动线程,都是调用的Thread类中的start()。 # 三、何为 java Thread类中的常用方法(之道) # ## 1、Thread常用方法 ## <table> <thead> <tr> <th>方法之道</th> <th>API方法含义</th> </tr> </thead> <tbody> <tr> <td>start()</td> <td>启动当前线程;调用当前线程的run()</td> </tr> <tr> <td>run()</td> <td>通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中</td> </tr> <tr> <td>currentThread()</td> <td>静态方法,返回执行当前代码的线程</td> </tr> <tr> <td>getName()</td> <td>获取当前线程的名字</td> </tr> <tr> <td>setName()</td> <td>设置当前线程的名字</td> </tr> <tr> <td>yield()</td> <td>释放当前cpu的执行权</td> </tr> <tr> <td>join()</td> <td>在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态。</td> </tr> <tr> <td>stop()</td> <td>已过时。当执行此方法时,强制结束当前线程。</td> </tr> <tr> <td>sleep(long millitime)</td> <td>让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内,当前线程是阻塞状态。</td> </tr> <tr> <td>isAlive()</td> <td>判断当前线程是否存活</td> </tr> </tbody> </table> ## 2、线程的优先级 ## <table> <thead> <tr> <th>变量</th> <th>默认值</th> </tr> </thead> <tbody> <tr> <td>MAX_PRIORITY</td> <td>10</td> </tr> <tr> <td>PRIORITY</td> <td>1</td> </tr> <tr> <td>NORM_PRIORITY</td> <td>5</td> </tr> </tbody> </table> ## 3、如何获取和设置当前线程的优先级 ## * getPriority():获取线程的优先级 * setPriority(int p):设置线程的优先级 * 说明:高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲,高优先级的线程高概率的情况下 * 被执行。并不意味着只有当高优先级的线程执行完以后,低优先级的线程才执行。 class HelloThread extends Thread{ @Override public void run() { for (int i = 0; i < 100; i++) { if(i % 2 == 0){ // try { // sleep(10); // } catch (InterruptedException e) { // e.printStackTrace(); // } System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i); } // if(i % 20 == 0){ // yield(); // } } } public HelloThread(String name){ super(name); } } public class ThreadMethodTest { public static void main(String[] args) { HelloThread h1 = new HelloThread("Thread:1"); // h1.setName("线程一"); //设置分线程的优先级 h1.setPriority(Thread.MAX_PRIORITY); h1.start(); //给主线程命名 Thread.currentThread().setName("主线程"); Thread.currentThread().setPriority(Thread.MIN_PRIORITY); for (int i = 0; i < 100; i++) { if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i); } // if(i == 20){ // try { // h1.join(); // } catch (InterruptedException e) { // e.printStackTrace(); // } // } } // System.out.println(h1.isAlive()); } } ## 3、java线程的生命周期 ## ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 2] 说明: * 1.生命周期关注两个概念:状态、相应的方法 * 2.关注:状态a–>状态b:哪些方法执行了(回调方法) 某个方法主动调用:状态a–>状态b * 3.阻塞:临时状态,不可以作为最终状态 死亡:最终状态。 # 四、何为线程同步机制(之道) # ## 1、背景 ## 例子:创建个窗口卖票,总票数为100张.使用实现Runnable接口的方式 * 1.问题:卖票过程中,出现了重票、错票 -->出现了线程的安全问题 * 2.问题出现的原因:当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票。 * 3.如何解决:当一个线程a在操作ticket的时候,其他线程不能参与进来。直到线程a操作完ticket时,其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞,也不能被改变。 ## 2、Java解决方案:同步机制(同步代码块 synchronized )(之道) ## 在Java中,我们通过同步机制,来解决线程的安全问题。 代码展示: **implements Runnabler 类** class Window1 implements Runnable{ private int ticket = 100; // Object obj = new Object(); // Dog dog = new Dog(); @Override public void run() { // Object obj = new Object(); while(true){ synchronized (this){ //此时的this:唯一的Window1的对象 //方式二:synchronized (dog) { if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket); ticket--; } else { break; } } } } } public class WindowTest1 { public static void main(String[] args) { Window1 w = new Window1(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } class Dog{ } **集成 extends Thread 类** * 使用同步代码块解决继承Thread类的方式的线程安全问题 * 例子:创建三个窗口卖票,总票数为100张.使用继承Thread类的方式 * 说明:在继承Thread类创建多线程的方式中,慎用this充当同步监视器,考虑使用当前类充当同步监视器。 class Window2 extends Thread{ private static int ticket = 100; private static Object obj = new Object(); @Override public void run() { while(true){ //正确的 // synchronized (obj){ synchronized (Window2.class){ //Class clazz = Window2.class,Window2.class只会加载一次 //错误的方式:this代表着t1,t2,t3三个对象 // synchronized (this){ if(ticket > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(getName() + ":卖票,票号为:" + ticket); ticket--; }else{ break; } } } } } public class WindowTest2 { public static void main(String[] args) { Window2 t1 = new Window2(); Window2 t2 = new Window2(); Window2 t3 = new Window2(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } ## 3、解决方法之一(以上两短代码都属于同步代码块) ## * * 方式一:同步代码块 * * synchronized(同步监视器){ * //需要被同步的代码 * * } * 说明:1.操作共享数据的代码,即为需要被同步的代码。 -->不能包含代码多了,也不能包含代码少了。 * 2.共享数据:多个线程共同操作的变量。比如:ticket就是共享数据。 * 3.同步监视器,俗称:锁。任何一个类的对象,都可以充当锁。 * 要求:多个线程必须要共用同一把锁。 * * 补充:在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器。 ## 4、解决方法之二(同步方法 synchronized ) ## * 使用同步方法解决实现Runnable接口的线程安全问题 * 关于同步方法的总结: * 同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。 * 非静态的同步方法,同步监视器是:this * 静态的同步方法,同步监视器是:当前类本身 **代码展示:** implements Runnable 类 class Window3 implements Runnable { private int ticket = 100; @Override public void run() { while (true) { show(); } } private synchronized void show(){ //同步监视器:this //synchronized (this){ if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket); ticket--; } //} } } public class WindowTest3 { public static void main(String[] args) { Window3 w = new Window3(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } * 使用同步方法处理继承Thread类的方式中的线程安全问题 * extends Thread class Window4 extends Thread { private static int ticket = 100; @Override public void run() { while (true) { show(); } } private static synchronized void show(){ //同步监视器:Window4.class //private synchronized void show(){ //同步监视器:t1,t2,t3。此种解决方式是错误的 if (ticket > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket); ticket--; } } } public class WindowTest4 { public static void main(String[] args) { Window4 t1 = new Window4(); Window4 t2 = new Window4(); Window4 t3 = new Window4(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } ## 5、解决线程安全问题的方式三:Lock锁 ## * 解决线程安全问题的方式三:Lock锁 — JDK5.0新增 1.面试题: synchronized 与 Lock的异同? * *相同*:二者都可以解决线程安全问题 * *不同*:synchronized机制在执行完相应的同步代码以后,自动的释放同步监视器 * Lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock()) **2.优先使用顺序:** * Lock: 同步代码块(已经进入了方法体,分配了相应资源) 同步方法(在方法体之外) * 面试题:如何解决线程安全问题?有几种方式 **3.利弊** 同步的方式,解决了线程的安全问题。—好处 操作同步代码时,只能一个线程参与,其他线程等待。相当于是一个单线程的过程,效率低。 **4.面试题** 面试题:Java是如何解决线程安全问题的,有几种方式?并对比几种方式的不同 面试题:synchronized和Lock方式解决线程安全问题的对比 class Window implements Runnable{ private int ticket = 100; //1.实例化ReentrantLock private ReentrantLock lock = new ReentrantLock(); @Override public void run() { while(true){ try{ //2.调用锁定方法lock() lock.lock(); if(ticket > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket); ticket--; }else{ break; } }finally { //3.调用解锁方法:unlock() lock.unlock(); } } } } public class LockTest { public static void main(String[] args) { Window w = new Window(); Thread t1 = new Thread(w); Thread t2 = new Thread(w); Thread t3 = new Thread(w); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start(); } } ## 6、使用同步机制将单例模式中的懒汉式改写为线程安全的。 ## class Bank{ private Bank(){ } private static Bank instance = null; public static Bank getInstance(){ //方式一:效率稍差 // synchronized (Bank.class) { // if(instance == null){ // // instance = new Bank(); // } // return instance; // } //方式二:效率更高 if(instance == null){ synchronized (Bank.class) { if(instance == null){ instance = new Bank(); } } } return instance; } } * 面试题:写一个线程安全的单例模式。 * 饿汉式。 * 懒汉式:上面提供的。 ## 7、死锁的理解 ## 1、**不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁** **2.说明:** * 出现死锁后,不会出现异常,不会出现提示,只是所的线程都处于阻塞状态,无法继续 * 我们使用同步时,要避免出现死锁。 **3.举例:** public static void main(String[] args) { StringBuffer s1 = new StringBuffer(); StringBuffer s2 = new StringBuffer(); new Thread(){ @Override public void run() { synchronized (s1){ s1.append("a"); s2.append("1"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s2){ s1.append("b"); s2.append("2"); System.out.println(s1); System.out.println(s2); } } } }.start(); new Thread(new Runnable() { @Override public void run() { synchronized (s2){ s1.append("c"); s2.append("3"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s1){ s1.append("d"); s2.append("4"); System.out.println(s1); System.out.println(s2); } } } }).start(); } # 五、何为线程通信(之道) # ## 1、线程通信涉及到的三个方法 ## 1. wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。 2. notify():一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级高的那个。 3. notifyAll():一旦执行此方法,就会唤醒所有被wait的线程。 ## 2、说明 ## 1. wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。 2. wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则,会出现IllegalMonitorStateException异常 3. wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中。 ## 3、面试题 ## **sleep() 和 wait()的异同?** 相同点: * 一旦执行方法,都可以使得当前的线程进入阻塞状态。 不同点: * 两个方法声明的位置不同:Thread类中声明sleep() , Object类中声明wait() * 调用的要求不同:sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中 * 关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁。 ## 4、小结释放锁的操作 ## ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 3] ## 5、小结不会释放锁的操作 ## ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 4] # 六、JDK5.0新增线程创建的方式 # ## 1、新增方式一:实现Callable接口。 — JDK 5.0新增 ## //1.创建一个实现Callable的实现类 class NumThread implements Callable{ //2.实现call方法,将此线程需要执行的操作声明在call()中 @Override public Object call() throws Exception { int sum = 0; for (int i = 1; i <= 100; i++) { if(i % 2 == 0){ System.out.println(i); sum += i; } } return sum; } } public class ThreadNew { public static void main(String[] args) { //3.创建Callable接口实现类的对象 NumThread numThread = new NumThread(); //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象 FutureTask futureTask = new FutureTask(numThread); //5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start() new Thread(futureTask).start(); try { //6.获取Callable中call方法的返回值 //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。 Object sum = futureTask.get(); System.out.println("总和为:" + sum); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } } ## 2、说明 ## * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大? 1. call()可以返回值的。 2. call()可以抛出异常,被外面的操作捕获,获取异常的信息 3. Callable是支持泛型的 ## 3、新增方式二:使用线程池 ## class NumberThread implements Runnable{ @Override public void run() { for(int i = 0;i <= 100;i++){ if(i % 2 == 0){ System.out.println(Thread.currentThread().getName() + ": " + i); } } } } class NumberThread1 implements Runnable{ @Override public void run() { for(int i = 0;i <= 100;i++){ if(i % 2 != 0){ System.out.println(Thread.currentThread().getName() + ": " + i); } } } } public class ThreadPool { public static void main(String[] args) { //1. 提供指定线程数量的线程池 ExecutorService service = Executors.newFixedThreadPool(10); ThreadPoolExecutor service1 = (ThreadPoolExecutor) service; //设置线程池的属性 // System.out.println(service.getClass()); // service1.setCorePoolSize(15); // service1.setKeepAliveTime(); //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象 service.execute(new NumberThread());//适合适用于Runnable service.execute(new NumberThread1());//适合适用于Runnable // service.submit(Callable callable);//适合使用于Callable //3.关闭连接池 service.shutdown(); } } ## 4、说明 ## * 好处: * 1.提高响应速度(减少了创建新线程的时间) * 2.降低资源消耗(重复利用线程池中线程,不需要每次都创建) * 3.便于线程管理 * corePoolSize:核心池的大小 * maximumPoolSize:最大线程数 * keepAliveTime:线程没任务时最多保持多长时间后会终止 # 5、面试题:Java中多线程的创建有几种方式?四种。 # 一共是上面讲述的几种、 [watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70]: /images/20221022/add121ca54c8493d897e624f884cb6ca.png [watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 1]: /images/20221022/29401c6ec87c4f7f8f3a32fa04b941b3.png [watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 2]: /images/20221022/6ccbcde051d34a1eab960a85a794a449.png [watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 3]: /images/20221022/489b651d9e0e4443b56b1ca4ffed835c.png [watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMDgyNzAx_size_16_color_FFFFFF_t_70 4]: /images/20221022/626d43893180491093c49ba376242d68.png
相关 多线程并发:Java线程同步死锁案例 在Java编程中,多线程并发和线程同步是两个重要的概念。下面我们将通过一个死锁的例子来深入理解。 首先,了解什么是死锁: - 死锁:两个或更多的线程因争夺资源而造成的一种互相 落日映苍穹つ/ 2024年09月18日 01:03/ 0 赞/ 17 阅读
相关 Java多线程问题:线程同步与死锁 在Java多线程编程中,线程同步和死锁是两个关键概念。 1. **线程同步**: - 同步是为了保证多个线程访问共享资源(如内存、文件等)时的顺序性和一致性。 - 曾经终败给现在/ 2024年09月16日 06:03/ 0 赞/ 23 阅读
相关 Java多线程问题:线程同步与死锁 在Java多线程编程中,线程同步和死锁是两个关键概念。 1. 线程同步: - **synchronized关键字**:这是Java中最常用的同步机制。在一个方法或者代码 太过爱你忘了你带给我的痛/ 2024年09月10日 16:45/ 0 赞/ 32 阅读
相关 多线程、声明周期、同步机制、死锁、线程池 的完整使用 小坏谈多线程、声明周期、同步机制、死锁、线程池 一、何为 java 线程之道(线程都包括那些) 1、程序(programm) 2、进程(p 怼烎@/ 2022年11月16日 13:38/ 0 赞/ 118 阅读
相关 多线程之线程同步、lock锁、死锁 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ub 蔚落/ 2022年10月23日 11:15/ 0 赞/ 232 阅读
相关 Java多线程同步死锁例程 在计算机领域有一个很经典的问题——哲学家进餐问题。在一个桌子旁边,围坐着五个哲学家,每个哲学家左右手边各有一支筷子。要求每个哲学家必须同时拿起两支筷子才可以吃饭。开始吃饭的时候 川长思鸟来/ 2022年06月17日 13:51/ 0 赞/ 201 阅读
相关 线程同步和线程死锁 1.线程同步,一个关键字:synchronized 为什么有这个东西呢,假如有一个对象,里面有成员变量和方法,如果有很多线程都想访问它们,有可能造成用户想避免的结果。 爱被打了一巴掌/ 2022年06月08日 03:48/ 0 赞/ 233 阅读
相关 java多线程学习系列:线程锁+线程池+线程同步 1、并发编程三要素? 1)原子性 原子性指的是一个或者多个操作,要么全部执行并且在执行的过程中不被其他操作打断,要么就全部都不执行。 2)可见性 可见性指多 小鱼儿/ 2022年02月26日 20:37/ 0 赞/ 384 阅读
相关 多线程2(线程安全,线程同步,死锁,lock锁,等待唤醒机制) 2.1 线程安全 如果有多个线程在同时运行,而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的, 怼烎@/ 2022年01月05日 13:21/ 0 赞/ 300 阅读
还没有评论,来说两句吧...