多线程，线程同步和锁

最新推荐文章于 2024-07-29 19:48:37 发布
最新推荐文章于 2024-07-29 19:48:37 发布
阅读量642 收藏 5
点赞数 1
分类专栏： Java进阶 文章标签： 多线程 锁 并发 线程池 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lgl782519197/article/details/113976132
版权

多线程，线程同步和锁

1：线程的创建

1-1：继承Thred类

package com.lingaolu;

public class CreateThread extends Thread{

    @Override
    public void run() {
        System.out.println("子线程执行");
    }

    public static void main(String[] args) {
        System.out.println(1);
        new CreateThread().start();
        System.out.println(2);
    }
}

在这里插入图片描述

1-2：实现Runnable接口

package com.lingaolu;

public class CreateThread implements Runnable{

    @Override
    public void run() {
        System.out.println("子线程执行");
    }

    public static void main(String[] args) {
        System.out.println(1);
        new Thread(new CreateThread()).start();
        System.out.println(2);
    }
}

        或者使用lambda表达式

package com.lingaolu;

public class CreateThread{

    public static void main(String[] args) {
        System.out.println(1);
        new Thread(()->System.out.println("子线程执行")).start();
        System.out.println(2);
    }
}

1-3：实现Callable<>接口，有返回值的线程

package com.lingaolu;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CreateThread implements Callable<String> {
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println(1);
        FutureTask<String> futureTask = new FutureTask<>(new CreateThread());
        new Thread(futureTask).start();
        // 这个get方法是阻塞的
        System.out.println(futureTask.get());
        System.out.println(2);
    }

    @Override
    public String call(){
        System.out.println("子线程执行");
        return "OK";
    }
}

在这里插入图片描述

2：线程的其他操作

        线程有5个状态，如下
在这里插入图片描述

2-1：线程停止

        我们不推荐线程使用**interrupt()，stop()，destroy()**等方法停止线程，而是自己写一个标记位来作为线程的终止变量

package com.lingaolu;


public class CreateThread implements Runnable{

    private boolean flag = true;
    
    @Override
    public void run() {
        while (flag){
            System.out.println("线程执行");
        }
    }

    // 调用方法，改变标志位的值来停止线程
    public void stop(){
        this.flag = false;
    }

}

2-2：线程礼让yield

  • 礼让线程，让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不一定成功，看cpu心情
package com.lingaolu;


public class CreateThread implements Runnable{
    
    public static void main(String[] args) {
        System.out.println(1);
        new Thread(new CreateThread(),"线程1").start();
        new Thread(new CreateThread(),"线程2").start();
        System.out.println(2);
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程执行开始");
        // 线程礼让
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程执结束");
    }

}

在这里插入图片描述

2-3：线程强制执行join

        join可以让线程强制执行

package com.lingaolu;


public class CreateThread implements Runnable{

    public static void main(String[] args) throws InterruptedException {
        System.out.println(1);
        Thread thread1 = new Thread(new CreateThread());
        thread1.start();
        for (int i = 1; i <= 5; i++) {
            if(i==3){
                // 当i=3时，强制让thread1执行
                thread1.join();
            }
            System.out.println("主线程"+i);
        }
        System.out.println(2);
    }

    @Override
    public void run() {
        System.out.println("子线程执行......");
    }

}

在这里插入图片描述

2-4：查看线程状态

package com.lingaolu;

import lombok.SneakyThrows;

public class CreateThread implements Runnable{

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(new CreateThread());
        Thread.State state = thread1.getState();
        System.out.println("线程创建状态"+state);
        thread1.start();
        state = thread1.getState();
        System.out.println("线程启动状态"+state);
        while(state != Thread.State.TERMINATED){
            if(state == Thread.State.TIMED_WAITING){
                System.out.println("线程等待状态"+state);
            }
            Thread.sleep(100);
            state = thread1.getState();
        }
        state = thread1.getState();
        System.out.println("线程结束状态"+state);
    }

    @SneakyThrows
    @Override
    public void run() {
        Thread.sleep(100);
        System.out.println("子线程执行状态......"+Thread.currentThread().getState());
        System.out.println("子线程执行......");
    }
}

        运行结果
在这里插入图片描述

2-5：线程优先级priority

        Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

  • 但是优先级高的只是意味着获得调度的高概率，并不是每次都会比优先级低的先调度，这个得看CPU的调度
package com.lingaolu;

import lombok.SneakyThrows;

public class CreateThread implements Runnable{

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new CreateThread(),"t1");
        Thread t2 = new Thread(new CreateThread(),"t2");
        Thread t3 = new Thread(new CreateThread(),"t3");
        Thread t4 = new Thread(new CreateThread(),"t4");
        Thread t5 = new Thread(new CreateThread(),"t5");
        t1.setPriority(1);
        t1.start();
        t2.setPriority(5);
        t2.start();
        t3.setPriority(Thread.MAX_PRIORITY);
        t3.start();
        t4.setPriority(2);
        t4.start();
        t5.setPriority(6);
        t5.start();
        System.out.println("主线程优先级为"+Thread.currentThread().getPriority());

    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"子线程执行......优先级为"+Thread.currentThread().getPriority());
    }
    
}

在这里插入图片描述

2-6：守护线程deamon

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线层执行完毕，比如：监控内存，垃圾回收等等
package com.lingaolu;

public class CreateThread{

    public static void main(String[] args) throws InterruptedException {
        Thread girlFriendThread = new Thread(new GirlFriend());
        // 守护主线程,主线程完毕，girlFriendThread也就完毕
        girlFriendThread.setDaemon(true);
        girlFriendThread.setPriority(10);
        girlFriendThread.start();
    }

}

class I implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("我一直守护女朋友");
        }
    }
}

class GirlFriend implements Runnable{
    @Override
    public void run() {
        Thread thread = new Thread(new I());
        // 默认false,false为正常线程，true为守护线程，守护上级线程
        thread.setDaemon(true);
        thread.start();
        for (int i = 1; i <= 30; i++) {
            System.out.println("女朋友线程执行"+i);
        }
    }
}

在这里插入图片描述

4：并发与锁

4-1：初识并发问题

        3个线程同时抢20张票，更详细的用法这里有介绍https://lingaolu.blog.csdn.net/article/details/106121766

package com.lingaolu;

import lombok.SneakyThrows;

public class CreateThread implements Runnable{

    private Boolean flag = true;
    private static int num = 20;

    public static void main(String[] args) {
        CreateThread createThread = new CreateThread();
        new Thread(createThread,"111线程").start();
        new Thread(createThread,"222线程").start();
        new Thread(createThread,"333线程").start();
    }
    
    @SneakyThrows
    @Override
    public void  run() {
        while (flag) {
            if (num > 0) {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+"抢了第"+num--+"张票");
            } else {
                flag = false;
            }
        }


    }
}

        从结果可以看出，不仅有线程抢到了相同的票，还有负的票，这就是线程安全问题
在这里插入图片描述

4-2：synchronized

        synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

  • 缺陷：若将一个大的方法申明为synchronized将会影响效率
  • 方法里面需要修改内容才需要锁，锁太多，浪费资源
package com.lingaolu;

import lombok.SneakyThrows;

public class CreateThread implements Runnable{

    private Boolean flag = true;
    private static int num = 20;
    private Object obj = new Object();

    public static void main(String[] args) {
        CreateThread createThread = new CreateThread();
        new Thread(createThread,"111线程").start();
        new Thread(createThread,"222线程").start();
        new Thread(createThread,"333线程").start();
    }

    @SneakyThrows
    @Override
    public void  run() {
        while (flag) {
            synchronized (obj) {
                if (num > 0) {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName() + "抢了第" + num-- + "张票");
                } else {
                    flag = false;
                }
            }
        }


    }
}

4-3：死锁

        多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”问题。

package com.lingaolu;

import lombok.Data;
import lombok.SneakyThrows;

@Data
public class CreateThread implements Runnable{
    private static Object obj1 = new Object();
    private static Object obj2 = new Object();

    private int num;

    public CreateThread(int num) {
        this.num = num;
    }

    public static void main(String[] args) {
        new Thread(new CreateThread(1),"111线程").start();
        new Thread(new CreateThread(2),"222线程").start();
    }

    @SneakyThrows
    @Override
    public void  run() {
        if(num==1){
            synchronized (obj1) {
                System.out.println(Thread.currentThread().getName()+"=====对象1");
                Thread.sleep(1000);
                synchronized (obj2) {
                    System.out.println(Thread.currentThread().getName()+"=====对象2");
                    Thread.sleep(1000);
                }
            }
        }else {
            synchronized (obj2) {
                System.out.println(Thread.currentThread().getName()+"=====对象2");
                Thread.sleep(1000);
                synchronized (obj1) {
                    System.out.println(Thread.currentThread().getName()+"=====对象1");
                    Thread.sleep(1000);
                }
            }
        }
    }
}

        发生死锁，if和else的代码块里面都互相等待对方的锁
在这里插入图片描述
        死锁解决，代码块不同时拥有2个对象锁以上，要分开

package com.lingaolu;

import lombok.Data;
import lombok.SneakyThrows;

@Data
public class CreateThread implements Runnable{
    private static Object obj1 = new Object();
    private static Object obj2 = new Object();

    private int num;

    public CreateThread(int num) {
        this.num = num;
    }

    public static void main(String[] args) {
        new Thread(new CreateThread(1),"111线程").start();
        new Thread(new CreateThread(2),"222线程").start();
    }

    @SneakyThrows
    @Override
    public void  run() {
        if(num==1){
            synchronized (obj1) {
                System.out.println(Thread.currentThread().getName()+"=====对象1");
                Thread.sleep(1000);
            }
            // 同步代码块锁分开
            synchronized (obj2) {
                System.out.println(Thread.currentThread().getName()+"=====对象2");
                Thread.sleep(1000);
            }
        }else {
            synchronized (obj2) {
                System.out.println(Thread.currentThread().getName()+"=====对象2");
                Thread.sleep(1000);
            }
            // 同步代码块锁分开
            synchronized (obj1) {
                System.out.println(Thread.currentThread().getName()+"=====对象1");
                Thread.sleep(1000);
            }
        }
    }
}

        成功解决
在这里插入图片描述

5：线程通信wait和notify()

5-1：管程法

        并发协作模型“生产者/消费者模式”

  • 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
  • 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
  • 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”
  • 生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
package com.lingaolu;

import lombok.Data;

@Data
public class CreateThread {
    public static void main(String[] args) {
        DemandPool demandPool = new DemandPool();
        new Productor(demandPool).start();
        new programmer(demandPool).start();
    }
}

// 生产者,产品
class Productor extends Thread{
    DemandPool demandPool;
    public Productor(DemandPool demandPool){
        this.demandPool = demandPool;
    }
    // 添加需求
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            demandPool.push(new Demand(i));
        }
    }
}

// 消费者，程序员
class programmer extends Thread{
    DemandPool demandPool;
    public programmer(DemandPool demandPool){
        this.demandPool = demandPool;
    }

    // 做需求
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            demandPool.pop();
        }
    }
}

// 产品，需求
class Demand{
    // 需求编号
    int id;

    public Demand(int id) {
        this.id = id;
    }
}

// 需求池
class DemandPool{
    // 需要一个容器大小
    Demand[] demands = new Demand[5];
    // 容器计数器
    int count = 0;

    // 产品加需求
    public synchronized void push(Demand demand){
        // 如果需求池满了，就需要等待程序员做需求
        if(count == demands.length){
            // 通知程序员做需求，产品等待加需求
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 如果没有满，产品就加需求
        System.out.println("产品添加了第"+demand.id+"个需求");
        demands[count] = demand;
        count++;
        // 可以通知程序员做需求
        this.notifyAll();

    }

    // 程序员做需求
    public synchronized Demand pop(){
        // 判断是否有需求
        if(count==0){
            // 等待产品的需求
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 可以做需求
        count--;
        Demand demand = demands[count];
        System.out.println("程序员做了第"+demand.id+"个需求");
        // 通知产品加需求
        this.notifyAll();
        return demand;
    }
}

        结果
在这里插入图片描述

5-2：信号灯法

        信号灯法就是使用一个标记位，判断标记位来等待启动，我们举个例子，产品 出什么需要，程序员就做什么需求

package com.lingaolu;

import lombok.Data;

@Data
public class CreateThread {
    public static void main(String[] args) {
        Demand demand = new Demand();
        new Productor(demand).start();
        new programmer(demand).start();
    }
}

// 生产者,产品
class Productor extends Thread{
    Demand demand;
    public Productor(Demand demand){
        this.demand = demand;
    }
    // 添加需求
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            this.demand.push(i);
        }
    }
}

// 消费者，程序员
class programmer extends Thread{
    Demand demand;
    public programmer(Demand demand){
        this.demand = demand;
    }

    // 做需求
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            this.demand.pop();
        }
    }
}

// 需求
class Demand{
    private  int id;
    private Boolean flag = true;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Demand() {
    }

    // 产品加需求
    public synchronized void push(int id){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.setId(id);
        System.out.println("产品添加了第"+id+"个需求");
        // 通知程序员做需求
        this.notifyAll();
        this.flag = !this.flag;
    }

    // 程序员做需求
    public synchronized void pop(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("程序员做了第"+id+"个需求");
        // 通知产品加需求
        this.notifyAll();
        this.flag = !this.flag;
    }
}

        结果
在这里插入图片描述

6：线程池

6-1：线程池例子

        JDK5.0起提供了线程池相关API：ExecutorService和Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

  • void execute(Runnable command)：执行任务命令。没有返回值，一般用来执行Runnable
  • Future submit(Callable task)：执行任务命令。有返回值，一般用来执行Callable
  • voidshutdown()：关闭连接池

Executors：工具类，线程池的工厂，用于创建并返回不同类型的线程池

比较重要的几个类：

  • ExecutorService： 真正的线程池接口。
  • ScheduledExecutorService： 能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。
  • ThreadPoolExecutor： ExecutorService的默认实现。
  • ScheduledThreadPoolExecutor： 继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现
package com.lingaolu;

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

public class CreateThread implements Runnable {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        // 执行线程
        executorService.execute(new CreateThread());
        executorService.execute(()->System.out.println("线程1执行"));
        executorService.execute(()->System.out.println("线程2执行"));
        executorService.execute(()->System.out.println("线程3执行"));
        // 关闭连接
        executorService.shutdown();
    }

    @Override
    public void run() {
        System.out.println("线程执行");
    }
}

        结果
在这里插入图片描述

6-2：自定义线程池（手动创建线程池，效果会更好）

        线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的
在这里插入图片描述

package com.lingaolu;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class CreateThread{
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                4,                   // 核心线程数
                8,              // 最大线程数
                5,                 // 存活时间
                TimeUnit.SECONDS,                  // 秒
                new LinkedBlockingDeque<>(300), // 队列大小300
                new MyThreadFactory(new ThreadGroup("myThreadGroup"),"my-thread"),  // 线程工厂
                new ThreadPoolExecutor.AbortPolicy()    // 拒绝策略（默认），所谓拒绝策略，是指将任务添加到线程池中时，线程池拒绝该任务所采取的相应策略
        );
        while (true){
            Thread.sleep(1000);
            threadPoolExecutor.execute(()->{
                Thread thread = Thread.currentThread();
                System.out.println(thread.getName());
            });
        }
    }

    static class MyThreadFactory implements ThreadFactory{
        private AtomicInteger number = new AtomicInteger(0);
        private ThreadGroup group;
        private String namePrefix;
        public MyThreadFactory(ThreadGroup group, String namePrefix) {
            this.group = group;
            this.namePrefix = namePrefix;
        }
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(group,r,namePrefix+"-"+number.getAndIncrement());
            if (t.isDaemon()){
                t.setDaemon(false);
            }
            if (t.getPriority() != Thread.NORM_PRIORITY){
                t.setPriority(Thread.NORM_PRIORITY);
            }
            return t;
        }
    }

}

        定的核心线程数是4个
在这里插入图片描述

深知她是一场梦
关注
专栏目录
多线程 加锁
Sarah_212的博客
09-24 3878
线程同步 对多线程来说，资源是共享的，基本上不存在不允许访问的情况，但是，共享的资源在某一时间点只能有一个线程占用，所以需要给资源加锁。 线程的锁的种类 互斥锁 读写锁 条件变量 自旋锁 信号灯 互斥锁 互斥锁机制是同一时刻只允许一个线程占有共享的资源。 初始化锁 intpthread_mutex_init(pthread_mutex_t*mutex,constpthread_mutex_attr_t*mutexattr); 参数 mutexattr 用于指定锁的属性（见下）...
Java多线程-线程的同步与锁的问题
09-01
Java多线程编程中，线程同步是一种解决并发问题的关键技术。当多个线程同时访问共享资源时，可能会引发数据不一致性和竞态条件。线程同步的主要目标是确保同一时间只有一个线程能够访问特定的代码段，以避免数据损坏...
多线程中的锁
qq_66292058的博客
03-13 1542
在了解什么是锁之前，我们先来看一下这样一段代码//创建变量i//我们创建两个线程,分别让i自增10000次j < 10000;j++) {i++;});j < 10000;j++) {i++;});t1.start();t2.start();try {//等待两个线程执行完成t2.join();t1.join();//打印i的值按照正常的逻辑，两个线程都让i自增了10000次，i最终的结果应该是20000才对，但事实真是如此吗？我们来看一下代码的运行结果。
【多线程】常见锁策略，CAS和synchronized
最新发布
daweidi的博客
07-29 1078
假设在大多数情况下并发操作不会发生冲突，因此允许多个线程同时进行操作，只有在真正更新数据时才进行冲突检测。：假设并发操作会发生冲突，因此在读取和修改数据时会进行加锁操作，保证同一时间只有一个线程能够操作数据。，可以提高并发性能，但可能会导致重复操作或数据丢失的问题。，能够确保数据的一致性，但并发性能相对较低。
多线程有哪些锁
TABE_的博客
08-26 2082
互斥锁是一种「独占锁」，比如当线程 A 加锁成功后，此时互斥锁已经被线程 A 独占了，只要线程 A 没有释放手中的锁，线程 B 加锁就会失败，于是就会释放 CPU 让给其他线程，既然线程 B 释放掉了 CPU，自然线程 B 加锁的代码就会被阻塞。自旋锁开销少，在多核系统下一般不会主动产生线程切换，但如果被锁住的代码执行时间过长，自旋的线程会长时间占用 CPU 资源，所以自旋的时间和被锁住的代码执行的时间是成「正比」的关系，我们需要清楚的知道这一点。互斥锁虽然简化了使用锁的难度，但是存在一定的性能开销，...
多线程的锁机制
我想静静
06-09 914
1、synchronized对象同步锁：synchronized是对对象加锁，可作用于对象、方法（相当于对this对象加锁）、静态方法（相当于对Class实例对象加锁，锁住的该类的所有对象）以保证并发环境的线程安全。同一时刻只有一个线程可以获得锁。 其底层实现是通过使用对象监视器Monitor，每个对象都有一个监视器，当线程试图获取Synchronized锁定的对象时，就会去请求对象监视器（Monitor.Enter()方法），如果监视器空闲，则请求成功，会获取执行锁定代码的权利；如果监视器已被其他线程持
Android多线程之同步锁的使用
01-04
本文主要介绍了Android多线程之同步锁的使用，分享给大家，具体如下： 一、同步机制关键字synchronized 对于Java来说，最常用的同步机制就是synchronized关键字，他是一种基于语言的粗略锁，能够作用于对象、函数...
Java 多线程同步 锁机制与synchronized深入解析
09-05
Java中的多线程同步是一种控制并发访问共享资源的方式，以防止数据不一致和线程冲突。锁机制是Java实现同步的主要手段，其中synchronized关键字扮演了核心角色。 synchronized可以用于修饰方法或代码块，两者在锁的...
Python利用多线程同步锁实现多窗口订票系统(推荐)
09-18
这是在多线程编程中常用的一个技术点，特别是在需要共享资源的场景下，比如数据库连接、文件操作等，同步锁都能够有效地避免数据竞争和不一致性的问题。同步锁可以确保同一时间只有一个线程可以执行被锁保护的代码段...
多线程的锁
CoderLai的博客
07-14 654
多线程的锁
多线程--锁 详解
qq_36657997的博客
03-08 519
多线程–锁 Synchorized 1 CAS 1.1 CAS概念 ​ CAS 即 （Compare And Swap / Compare And Set /Compare And Exchange）比较并交换，一种实现并发算法时用到的技术，是 JAVA 很多底层并发包的实现原理。 1.2 案例 先做一个实验，示例如下： public static volatile int v1 = 0; //定义一个共享变量 public staic void incease1(){ //自增 v1++; }
多线程中锁的实现.
阿堂的专栏
10-04 3303
*引用本文请注明来自 blog.csdn.net/wtz1985        所谓"锁",就是为了让自己独自占有空间,在自己没用完之前,不让别人来占用自己的资源.现在的操作系统,无论是WINDOWS,还是UNIX等其他操作系统.都采用多线程的环境.这极大提高了任务的执行速度,而且不会影响其他事务的执行.但是它们的执行是靠时间片的轮转的,如果某一个线程没有执行完,可它的时间片用完了,就会被挂起
多线程同步与锁
胡杰的专栏
07-22 2262
多线程同步与锁 本次主要讨论的是lock,autoeventset,moniter 代码如下 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; namespace ConsoleApplication1
多线程加锁
ffeng271的专栏
02-08 5753
Linux pthread_mutex演示程序 C++语言: Linux pthread_mutex演示程序 Linux 下pthread 中使用mutex 进行互斥的程序和结果 #include "stdio.h" #include "string.h" #include "stdlib.h" #include "pthread.h" #define THREA
多线程间的几种锁
蓬莱道人的博客
12-13 3778
1、互斥量（互斥锁） 2、读写锁（共享互斥锁） 3、自旋锁 4、条件变量 5、屏障 1、互斥量（互斥锁） #include<pthread.h> // 初始化互斥量 int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr); // 销毁互斥量 int pthread_mutex_destroy(pthread_mutex_t *mut
java 多线程 串行 加锁_Java 多线程加锁
weixin_39759270的博客
02-16 227
以前的同步操作 基本上都是用到 synchronized 关键字，类似代码如下：synchronized(obj){//dosomething...}来做到同步，在 JDK5.0 里面有这么一个对象，ReentrantLock，发觉她的加锁编程的方式非常的适合日常的加锁习惯，EG：package com.thread.synchronise;import java.util.concurrent...
多线程中的锁详解
NanCheng_666的博客
11-10 292
当一个线程需要访问共享资源时，它需要先获取互斥锁，如果锁已被其他线程占用，则当前线程会被阻塞，直到获得锁为止。总的来说，锁是多线程编程中非常重要的一种机制，能够避免线程之间的竞争和冲突，从而保证程序的正确性和稳定性。如果锁已被其他线程占用，则当前线程会不断地尝试获取锁，直到获得锁为止。但是，在高并发场景下，如果锁竞争比较激烈，大量的自旋操作会导致CPU资源浪费，因此需要根据具体场景进行选择。互斥锁的主要优点是能够避免竞争条件，但是在高并发场景下，由于线程的阻塞和唤醒需要时间开销，因此可能会降低程序的性能。
Python多线程同步：理解锁与数据共享
通过学习和理解Python锁的使用，开发者可以编写出更健壮和高效的多线程程序，避免数据混乱和潜在的错误。在实际项目中，根据具体需求选择合适的同步策略，如`Lock`、`Semaphore`或`RLock`等，以实现最佳的并发性能和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

深知她是一场梦

你打不打赏，我都会一直写博客

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值