Java多线程（2）之线程同步

于 2024-08-08 17:48:26 发布
阅读量773 收藏 4
点赞数 14
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76908023/article/details/140996126
版权

一、简介：

       当多个线程共享数据时，由于CPU负责线程的调试，所以程序无法精确地控制多线程的交替次序。如果没有特殊控制，则多线程对共享数据的修改和访问将导致数据的不一致。

二、为什么需要线程同步：

      上篇学习的线程都是独立且异步运行的，也就是说每个线程都包含了运行时所需要的数据或方法，不必关心其他线程的状态和行为。但是经常会有一些同时运行的线程需要操作共同数据，此时就要考虑其他线程的状态和行为；否则，不能保证程序运行结果的正确。

三、线程同步解决的问题：

线程同步是多线程编程中的一个重要概念，它主要解决以下几个问题：

  1. 数据一致性：在多线程环境中，如果多个线程同时访问和修改共享数据，可能会导致数据的不一致性。线程同步确保在任何时刻，只有一个线程能够修改共享数据。

  2. 避免竞态条件：竞态条件是指多个线程的执行顺序影响程序结果的情况。线程同步可以控制线程的执行顺序，防止竞态条件的发生。

  3. 提高效率：通过合理的线程同步，可以减少线程间的不必要等待，提高程序的执行效率。

  4. 资源分配：在多线程程序中，某些资源（如文件、数据库连接等）是有限的。线程同步可以确保这些资源被合理分配，避免资源冲突。

  5. 互斥：在访问某些需要互斥操作的资源时，线程同步可以保证在执行这些操作时，不会有其他线程同时访问。

  6. 协调线程：线程同步可以协调线程之间的工作，例如，通过同步机制，可以让一个线程等待另一个线程完成特定的任务后再继续执行。

四、实现线程同步：

当两个或多个线程需要访问同一资源时，需要以某种顺序来确保该资源某一时刻只能被一个线程使用，这称为线程同步。线程同步相当于为线程中需要一次性完成不允许中断的操作加上一把锁，从而解决冲突。

方式有两种：

（1）添加同步代码块：

代码块即使用"{}"括起来的一段代码，使用synchronized关键字修饰的代码块被称为同步代码块。其语法如下。

synchronized(obj){

  //需要同步的代码

}

如果一个代码块带有synchronized(obj)标记，那么当线程执行代码时，必须先获得obj变量所引用的对象的锁，其可针对任何代码块，并且可以任意指定上锁的对象，因此灵活性更高。

（2）添加同步方法：

如果一个方法的的代码都属于需同步的代码，那么这个方法定义处可以直接使用synchronized关键字修饰，即同步方法。其语法如下。

访问修饰符 synchronized 返回类型 方法名(参数列表) {//省略方法体……}

或

synchronized访问修饰符 返回类型 方法名(参数列表) {//省略方法体……}

五、在java中有哪些线程同步机制：

在Java中，常用的线程同步机制包括以下几种：

  1. synchronized关键字：

    • 可以用于方法或代码块，确保同一时间只有一个线程可以执行该段代码。
    • 可以用于对象锁（任意对象实例）和类锁（使用ClassName.class）。

  2. Lock接口及其实现类：

    • Java并发API提供了Lock接口，如ReentrantLock，提供了比synchronized更丰富的锁操作，如尝试非阻塞获取锁、可中断的锁获取等

  3. wait/notify机制：

    • 与synchronized结合使用，允许线程在某些条件不满足时挂起，并在条件满足时被其他线程唤醒。

这些同步机制可以单独使用，也可以组合使用，以满足不同的线程同步需求。正确使用这些机制对于避免并发问题和提高程序性能至关重要。

六、使用synchronized关键字实现线程同步机制的步骤：

使用 synchronized 关键字实现同步机制通常遵循以下步骤：

  1. 确定锁对象：

    • 首先需要确定一个对象作为锁对象（Lock Object），这个对象将用于同步线程的访问。通常可以使用当前实例对象 this，或者定义一个专门的锁对象。

  2. 同步方法：

    • 你可以将整个方法声明为同步的，通过在方法声明前加上 synchronized 关键字。这样，任何时候只有一个线程可以执行该对象的所有同步实例方法。
  • public synchronized void myMethod() { // 方法体 }

  • 同步代码块：

    • 如果只需要同步方法中的部分代码，可以使用同步代码块。在需要同步的代码前使用 synchronized 关键字，并指定锁对象。
    • public void myMethod() { synchronized (this) { // 需要同步的代码 } }
  1. 访问共享资源：
    • 在同步的方法或代码块中，可以安全地访问和修改共享资源，因为此时只有一个线程可以执行这部分代码。
  2. 避免死锁：
    • 使用 synchronized 时要注意避免死锁的发生。确保按照一致的顺序获取锁，或者使用超时机制尝试获取锁。
  3. 最小化同步区域：
    • 尽量缩小同步代码块的范围，只对需要同步的代码进行同步，以减少线程阻塞的时间，提高程序的并发性能。
  4. 释放锁：
    • 当同步代码块执行完毕后，锁会自动释放，允许其他线程进入同步区域。如果同步是通过方法实现的，方法执行完毕后锁也会被释放。
  5. 测试和调试：
    • 同步代码可能会引入并发问题，因此需要进行充分的测试和调试，确保程序在多线程环境下的正确性和性能。

 七、使用synchronized的实例测试代码：

测试代码一：

通过实现runnable接口，实现同步：


public class Thread8 implements Runnable{
   private int count=0;
    @Override
    public void run() {
        while (true){
            synchronized (this){
                if (count<=100){
                    System.out.println(Thread.currentThread().getName()+":"+count++);
                    notify();
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread8 thread8 = new Thread8();
        Thread thread1 = new Thread(thread8,"thread1");
        Thread thread2 = new Thread(thread8,"thread2");
        thread1.start();
        thread2.start();
    }
}

测试代码二：

对上述方法的一个实例应用


public class Thread9 implements Runnable {
   private  int ticket=100;
   Object obj=new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if (ticket>0){
                    System.out.println(Thread.currentThread().getName()+":"+"卖"+ticket);
                    ticket--;
                }else{
                    System.out.println("票卖完了");
                    ticket--;
                    break;
                }
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        Thread9 thread9 = new Thread9();
        Thread thread1 = new Thread(thread9);
        Thread thread2 = new Thread(thread9);
        Thread thread3 = new Thread(thread9);
        thread1.start();thread2.start();
        thread3.start();
    }
}

测试代码三：

使用同步代码块的一个实例：（卖包子）

继承Thread类来实现，同步代码块控制的实际是包子

创建一个包：建立三个java类和一个test类：

第一个java类代码：

第二个java类代码：


public class Baozipu extends Thread{
    private BaoZi bz;
    public Baozipu(BaoZi bz){
        this.bz=bz;
    }
    //设置线程任务，生产包子
    //重写run方法
    @Override
    public void run() {
        int count=0;
        while (true){
//同步代码块：
            synchronized (bz){
                if (bz.flag==true){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//完成制作包子
                if (count %2==0){
                    bz.pi="薄皮";
                    bz.xian="三鲜";
                }else {
                    bz.pi="冰皮";
                    bz.xian="牛肉";
                }
                count++;
                System.out.println("正在生产："+bz.pi+bz.xian++"包子"+"吃货正在等待中");
                //生产时间
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                bz.flag=true;
                bz.notify();//唤醒线程
                System.out.println("包子店的包子生产好啦："+bz.pi+bz.xian+"吃货可以开始吃啦");
            }
        }
    }
}

第三个java类代码：

package Thread;

public class ChiHuo extends Thread{
    private BaoZi bz;
    public ChiHuo(BaoZi bz){
        this.bz=bz;
    }
    @Override
    public void run() {
        //吃包子
        while (true){
            synchronized (bz){
                if (bz.flag==false){
                    try {
                        bz.wait();//等待生产
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("吃货正在吃："+bz.pi+bz.xian+"包子");
                bz.flag=false;//修改包子的状态
                bz.notify();//唤醒包子铺线程，生产包子
                System.out.println("吃货已经吃完了："+bz.pi+bz.xian+",包子铺生产包子中");
            }
        }
    }
}

测试它的代码：

package Thread;

public class Test {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi baoZi = new BaoZi();
        //生产包子
        new Baozipu(baoZi).start();
        //吃包子
        new ChiHuo(baoZi).start();

    }
}

八、使用Lock接口及其实现类实现同步操作：

1.获取Lock对象：

  • 首先，需要创建一个 Lock 对象的实例。通常使用 ReentrantLock 类。
  • Lock lock = new ReentrantLock();

2.尝试获取锁：

  • 在访问共享资源之前，使用 lock.lock() 方法尝试获取锁。
  • lock.lock(); 
try {
 // 访问或修改共享资源
 } 
finally {
 // 确保释放锁 lock.unlock();
 }

3.使用try-finally结构： 

        使用 try-finally 结构确保即使在发生异常的情况下也能释放锁。

4.避免死锁： 

  • 避免死锁：

    • 即使使用 Lock 接口，也要注意避免死锁的发生，确保锁的获取和释放顺序一致。

  • 测试和调试：

    • 使用 Lock 接口编写的代码也需要进行充分的测试和调试，确保在多线程环境下的正确性和性能。

九、 使用Lock接口及其实现类测试代码：

测试代码一：


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LOck1 {
    private final Lock lock=new ReentrantLock();
    private int count=0;
    public void increment(){
        lock.lock();
        try {
            count++;
        }
        finally{
            lock.unlock();
        }
    }
    public int getCount(){
        lock.lock();
        try {
           return count;
        }
        finally{
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        //通过Runnable多态指向一个工作的多线程
        LOck1 lOck1 = new LOck1();
        Runnable task=() ->{
            for (int i = 0; i < 1000; i++) {
                lOck1.increment();

                System.out.println("lOck1.getCount() = " + lOck1.getCount());
            }
        };
//非常重要，没有的话就不能实现
        task.run();
    }
}

测试代码二：


import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Lock2 {
    //创建锁对象
    private Lock lock=new ReentrantLock();
    //创建共享对象
    private int add=0;
    //处理数据的方法
    public void addSue(){
        lock.lock();
        try {
            add++;
        }finally {
            lock.unlock();
        }
    }
    public int getAdd(){
        return add;
    }
    public static void main(String[] args) {
        Lock2 lock2 = new Lock2();
        //使用多线程模拟并发操作，创建多个线程
        for (int i = 0; i <5000 ; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    lock2.addSue();
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程的计算结果"+lock2.getAdd());
    }
}

十、以下是Lock锁的一些关键特点和简单说明：

1.显式获取和释放：使用Lock，你需要显式地调用lock()方法来获取锁，并在完成后调用unlock()方法来释放锁。这提供了比synchronized更多的灵活性，因为你可以选择在代码的任何位置获取和释放锁。

2.可中断的获取锁：Lock接口提供了lockInterruptibly()方法，允许线程在等待获取锁时被中断。这对于响应取消操作或超时等外部信号很有用。

3.尝试获取锁：通过tryLock()方法，线程可以尝试获取锁，如果锁当前不可用，则不会阻塞，而是立即返回。这可以用于非阻塞算法或当你不希望线程无限期等待时。

4.定时获取锁：tryLock(long time, TimeUnit unit)方法允许线程在指定的时间内尝试获取锁。如果在这个时间内锁变得可用，则线程会获取锁；否则，线程会放弃并返回。

5.多个锁和锁排序：与synchronized只能锁定单个对象不同，你可以使用多个Lock实例来锁定不同的对象或资源。这提供了更细粒度的并发控制，并允许你以特定的顺序获取多个锁，从而避免死锁。

6.可重入性：ReentrantLock是Lock接口的一个实现，它是可重入的，这意味着同一个线程可以多次获取同一个锁，而不会导致死锁。每次获取锁时，锁的内部计数器会增加；每次释放锁时，计数器会减少。只有当计数器为0时，其他线程才能获取该锁。

7.公平性和非公平性：ReentrantLock可以配置为公平锁或非公平锁。公平锁按照线程请求锁的顺序来授予锁，这有助于减少饥饿现象；而非公平锁则不保证这个顺序，可能会导致某些线程长时间等待。默认情况下，ReentrantLock是非公平的，但可以通过构造函数指定为公平的。

使用Lock接口和它的实现类（如ReentrantLock）可以提供更强大和灵活的并发控制机制，但也需要更多的注意和谨慎，以确保正确地获取和释放锁，避免死锁和其他并发问题。

十一、synchronized和Lock的区别：

synchronized是java关键字，而Lock是java中的一个接口

    2、synchronized会自动释放锁，而Lock必须手动释放锁

    3、synchronized是不可中断的，Lock可以中断也可以不中断

    4、通过Lock可以知道线程有没有拿到锁，而synchronized不能

    5、synchronized能锁住方法和代码块，而Lock只能锁住代码块

    6、Lock可以使用读锁提高多线程读效率

    7、synchronized是非公平锁，ReentranLock可以控制是否公平锁

十二、公平锁和非公平锁的区别：

公平锁：

每个线程获取锁的顺序是按照线程访问锁的先后顺序获取的，最前面的线程总是最先获取到锁。

非公平锁：

每个线程获取锁的顺序是随机的，并不会遵循先来先得的规则，所有线程会竞争获取锁。

 举个例子：公平锁就像开车经过收费站一样，所有的车都会排队等待通过，先来的车先通过，

例子：ReentrantLock 同时支持两种锁：

//创建一个非公平锁，默认是非公平锁

Lock nonFairLock= new ReentrantLock();

Lock nonFairLock= new ReentrantLock(false);

//创建一个公平锁，构造传参true

Lock fairLock= new ReentrantLock(true);

适用场景：

更多的是直接使用非公平锁：非公平锁比公平锁性能高5-10倍，因为公平锁需要在多核情况下维护一个队列，如果当前线程不是队列的第一个无法获取锁，增加了线程切换次数。

十三、乐观锁和悲观锁的区别

乐观锁和悲观锁是两种不同的并发控制策略，它们在处理数据时持有不同的态度和假设。

//1.悲观锁

态度：悲观地认为如果不严格同步线程调用，那么一定会产生异常。

机制：使用互斥锁将资源锁定，只供一个线程调用，阻塞其他线程。

适用场景：适用于写多读少的情况3。

实现：传统关系型数据库中的行锁、表锁、读锁、写锁等，以及Java中的synchronized和ReentrantLock等独占锁4。

//2.乐观锁

态度：乐观地认为别人不会同时修改数据。

机制：不会上锁，但在更新时会判断在此期间别人是否修改了数据，可以使用版本号机制和CAS算法实现

适用场景：适用于写少读多的情况，可以提高吞吐量3。

实现：Java中的java.util.concurrent.atomic包下的原子变量类使用了乐观锁的一种实现方式，即CAS4。

总结：

悲观锁通过锁定资源来避免并发冲突，适用于写多读少的情况，但会导致资源长时间被占用，降低并发性能。乐观锁则通过乐观的态度和检查机制来减少锁的使用，适用于写少读多的情况，可以提高系统的吞吐量，但可能会导致数据不一致的问题。选择哪种策略取决于具体的应用场景和需求。

十四、多线程编程之线程池（Thread Pool）：

     在Java多线程编程中，线程池（Thread Pool）是一种用于优化线程管理的技术。线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的ThreadFactory创建一个新线程。

（一）、线程池的主要优势在于：

1.降低资源消耗：通过重复利用已创建的线程，避免线程的频繁创建和销毁所带来的性能开销。

2.提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行。

3.提高系统的稳定性：由于线程数量得到有效控制，可以避免大量的线程导致系统资源耗尽的情况。

4.Java的java.util.concurrent包提供了几个用于创建线程池的工厂方法和类，如Executors.newFixedThreadPool、Executors.newCachedThreadPool、Executors.newSingleThreadExecutor等。这些工厂方法返回实现了ExecutorService接口的线程池对象，该接口定义了一些用于管理线程池的方法，如submit（提交任务）、shutdown（关闭线程池）等。

（二）、使用线程池时，开发者需要注意以下几点：

1.线程池的大小应根据实际的应用场景和需求来设定，避免过大或过小。

2.对于耗时的任务，应考虑使用异步执行，避免阻塞主线程或线程池中的其他线程。

3.需要合理处理任务执行过程中可能出现的异常，避免影响线程池的稳定性和可用性。

4.当不再需要线程池时，应调用shutdown或shutdownNow方法来关闭线程池，释放资源。

十五、下面是使用ExecutorService线程执行器的基本步骤：

1.创建线程池：使用Executors类中的静态工厂方法来创建线程池。例如，newFixedThreadPool、newCachedThreadPool或newSingleThreadExecutor。

2.提交任务：使用submit或execute方法将任务提交给线程池。submit方法返回一个Future对象，可以用于获取任务的结果；而execute方法不返回任何结果。

3.等待任务完成：如果使用了submit方法，并且需要获取任务的结果，可以使用Future对象的get方法来等待任务完成并获取结果。

4.关闭线程池：当不再需要线程池时，应调用shutdown或shutdownNow方法来关闭它。

十六、下面是一个使用ExecutorService线程执行器的示例：

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class ThreadPoolExecutorExample {

    public static void main(String[] args) throws Exception {

        // 创建一个固定大小的线程池

        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // 提交任务并获取Future对象

        Future<String> future = executorService.submit(new CallableTask());

        // 等待任务完成并获取结果

        String result = future.get();

        System.out.println("Task result: " + result);

        // 关闭线程池

        executorService.shutdown();

    }

}

class CallableTask implements Callable<String> {

    @Override

    public String call() throws Exception {

        System.out.println("Task executed by thread: " + Thread.currentThread().getName());

        // 模拟任务执行时间

        Thread.sleep(2000);

        return "Task result";

    }

}

在这个示例中，我们创建了一个CallableTask类，它实现了Callable<String>接口。Callable接口类似于Runnable接口，但它允许任务返回一个结果。submit方法接受一个Callable对象，并返回一个Future对象，可以用来获取任务的结果。

在main方法中，我们创建了一个固定大小的线程池，并提交了一个CallableTask任务。我们使用future.get()方法等待任务完成并获取结果。最后，我们调用shutdown方法来关闭线程池。

请注意，当使用Future.get()方法时，如果任务尚未完成，调用线程将阻塞，直到任务完成。因此，在生产代码中，可能需要更复杂的逻辑来处理这种情况，例如使用超时或异步处理结果。

此外，使用线程池时还需要注意异常处理。如果任务在执行过程中抛出异常，它将被封装在ExecutionException中抛出，因此在调用future.get()时需要处理这种异常。同样，如果线程池关闭时任务尚未完成，get方法将抛出CancellationException。

十七、下面是线程池的测试代码：

测试代码一：


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

public class Example1 {
    public static void main(String[] args) {
        //创建一个固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        //提交任务到线程池指向
        for (int i = 0; i <10; i++) {
            executorService.execute(new Work());
        }
        //关闭线程流
        executorService.shutdown();
    }
}

测试代码二：


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

public class Example2 {
    public static void main(String[] args) {
        //创建一个固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        //提交任务到线程池指向
        for (int i = 0; i <10 ; i++) {
            final int work=i;
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程任务"+work+"正在运行"+Thread.currentThread().getName());
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程工作任务"+work+"结束");
                }
            });
        }
        //关闭线程流
        executorService.shutdown();
    }
}

unoliiskam
关注
  • 14
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程实战-实现多线程文件下载，支持断点续传、日志记录等功能
qq_35716689的博客
03-10 18万+
本文将介绍如何通过Java来实现一个多线程下载器。作者：牵着猫散步的鼠鼠
Java多线程——线程同步
u010759175的专栏
12-28 2912
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
Java多线程 - 线程同步
honvin的博客
09-22 3926
线程同步，主要是应用在多个线程操作同一个资源。 并发：同一个对象被多个线程同时操作。 例子： 上万人同时抢100张票 一个账号在两个银行同时取钱 现实生活中，并发情况很常见。比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是排队，一个个来。 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象这时候我们就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问，此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。 排队的形成条件：队列 + 锁 由
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
JAVA多线程之线程同步
qq_39367410的博客
10-09 3021
线程同步、并发的基本概念以及解决问题的三种方法
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
Java多线程之线程同步
wshjk的博客
03-26 3121
线程同步 线程同步：当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多。 为什么要创建多线程？ 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。 为什么要线程同步 多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。 例如：我们去银行存钱，那肯.
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
详解java多线程的同步控制
01-20
同步控制是并发程序必不可少的重要手段，本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
学习Java多线程之同步
09-02
Java多线程同步是编程中一个重要的概念，特别是在并发编程中。当多个线程需要访问共享资源时，如果不加以控制，可能会导致数据不一致、竞态条件等问题。本篇文章将深入探讨Java中的同步机制，包括锁对象和条件对象。...
Java多线程编程之CountDownLatch同步工具使用实例
09-03
在Java多线程编程中，CountDownLatch是一种常用的同步工具，用于协调多个线程之间的协作，确保它们按照特定的顺序执行或者等待所有线程完成特定任务后再继续执行。这个类是java.util.concurrent包的一部分，提供了...
基于Java回顾之多线程同步的使用详解
09-05
总之，Java多线程同步是一个深度和广度都很宽的领域，理解并掌握这些机制对于编写高效、稳定的并发程序至关重要。在编写多线程代码时，要时刻警惕可能出现的并发问题，如死锁、活锁、饥饿等，并使用适当的方法进行...
如何使用CountDownLatch同步java多线程
08-18
如何使用CountDownLatch同步java多线程 CountDownLatch 是 Java 并发编程中的一种常用工具，用于控制多个线程的并发执行。它可以实现多个线程之间的同步操作，使得线程之间可以协调工作，避免了线程之间的互相干扰...
J031_使用TCP协议支持与多个客户端同时通信
lzn20161229的博客
08-03 450
使用TCP协议支持与多个客户端同时通信。
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1016
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 213
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
最新发布
荆赫同艺的博客
08-07 128
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值