同步锁2

 1 import threading
 2 import time
 3
 4 num = 100
 5 def add():
 6     global num
 7     s = num
 8     time.sleep(0.02)
 9     num = s - 1
10
11 l = list()
12 for i in range(100):
13     t = threading.Thread(target=add)
14     l.append(t)
15     t.start()
16 for i in l:
17     i.join()
18 print(num)
19 输出:
20 99
21
22 进程完成,退出码 0

遇到了IO阻塞,进行了切换。

单个线程中间发生了切换。任务只处理了一半。    需要拿出一个解决的办法将正在执行的线程处理完,在进行下一个线程。

可以进行加上同步锁lock = threading.Lock(),使其变成不阻塞

 1 import threading
 2 import time
 3
 4 num = 100
 5 lock = threading.Lock()
 6 def add():
 7     lock.acquire()
 8     global num
 9     s = num
10     time.sleep(0.02)
11     num = s - 1
12     lock.release()
13
14 l = list()
15 for i in range(100):
16     t = threading.Thread(target=add)
17     l.append(t)
18     t.start()
19 for i in l:
20     i.join()
21 print(num)
22 输出:
23 0
24
25 进程完成,退出码 0

加上锁之后就变成串行。

但是串行的就只有加锁的这三行,所以加锁还是有意义的。其它的代码照常同时是并行的执行。

  1 import threading
  2 import time
  3
  4 num = 100
  5 lock = threading.Lock()
  6 def add():
  7
  8     global num
  9     print(num)
 10     lock.acquire()
 11
 12     s = num
 13
 14     time.sleep(0.02)
 15     num = s - 1
 16     lock.release()
 17
 18 l = list()
 19 for i in range(100):
 20     t = threading.Thread(target=add)
 21     l.append(t)
 22     t.start()
 23 for i in l:
 24     i.join()
 25 print(num)
 26 输出:
 27 100
 28 100
 29 100
 30 100
 31 100
 32 100
 33 100
 34 100
 35 100
 36 100
 37 100
 38 100
 39 100
 40 100
 41 100
 42 100
 43 100
 44 100
 45 100
 46 100
 47 100
 48 100
 49 100
 50 100
 51 100
 52 100
 53 100
 54 100
 55 100
 56 100
 57 100
 58 100
 59 100
 60 100
 61 100
 62 100
 63 100
 64 100
 65 100
 66 100
 67 100
 68 100
 69 100
 70 100
 71 100
 72 100
 73 100
 74 100
 75 100
 76 100
 77 100
 78 100
 79 100
 80 100
 81 100
 82 100
 83 100
 84 100
 85 100
 86 100
 87 100
 88 100
 89 100
 90 100
 91 100
 92 100
 93 100
 94 100
 95 100
 96 100
 97 100
 98 100
 99 100
100 100
101 100
102 100
103 100
104 100
105 100
106 100
107 100
108 100
109 100
110 100
111 100
112 100
113 100
114 100
115 100
116 100
117 100
118 100
119 100
120 100
121 100
122 100
123 100
124 100
125 100
126 100
127 0

这就是处理办法

原文地址:https://www.cnblogs.com/ch2020/p/12688828.html

时间: 2024-07-29 06:25:52

同步锁2的相关文章

《GCD 实现同步锁》-07-多线程

@MicroCai 2015-03-03 23:18 字数 6539 阅读 202 Effective Objective-C Notes:GCD 实现同步锁 Archives iOS <Effective Objective-C Notes>系列博文整理自<Effective Objective-C 2.0> 如果您觉得我的博客对您有帮助,请通过关注我的新浪微博  MicroCai 支持我,谢谢! 本文名为<GCD 实现同步锁>,内容不止于锁.文章试图通过 GCD 同

java 同步锁(synchronized)

java 同步锁(synchronized) 在java中,Synchronized就是一把锁,他可以锁定一个方法,也可以锁定一个方法,我擦,其实这两个东西就是一样的.块不就是一个没有名字的方法么,方法就是一个有名字的块.本文就用块来测试.所谓锁,就是原子操作,把这个锁定的块作为一个整体,就像你上厕所,拉了就要擦屁屁,当然你也可以不擦,如果你不在意出现的问题的话.信号量Semaphore和这个Synchronized 其实实现的功能差不多,不过效率不同,使用的方式也不同.Synchronized

多用派发队列,少用同步锁

今天晚上,第二遍阅读“多用派发队列,少用同步锁”,并且是一遍理解,一遍敲代码.阅读完这节之后,不明觉历. 我就把我理解的,和作者所要表达的整理出来.(书名<编写高质量iOS与OS X代码的52个有效方法>) 在编码过程中,如果有多个线程要执行同一份代码,那么有时候会出现问题,比如set方法和get方法顺序错乱,就会导致输出结果不是自己期望的. 遇到这种情况 我讲列出几种解决方案,最后我会讲出最优质的代码. 1.采用内置的“同步块”(synchronization block) - (void)

传统多线程之同步锁(二)

一. 线程安全 线程安全问题是指程序中公用的东西被多个线程访问,比如:类的静态变量 二. 同步锁 有什么办法可以解决线程安全问题呢?那就是在程序中加锁 Java有两种加锁的方法: 1. 在代码块中加锁 synchronized (this) { ... } 2. 在方法上加锁 public synchronized void xxx(){ ... } 示例代码: public class TraditionalThreadSynchronized { public static void mai

MongoDB Secondary 延时高(同步锁)案例分析

遇到问题:晚10点,DBA在数据库建立了某collection的索引.在之后的几分钟,恰巧有同事访问某应用,验证该应用的账号需从数据库某表查询账号密码.导致了无法查询,同事无法登录上应用.问题便反馈到了运维部. 背景介绍: Mongodb版本 3.0.2 建索引和collection和账号查询collection所在同一台服务器,不同库名上. 因使用的是mongodb3.0.2,之前了解到3.0是行级锁,于是dba在建该表索引时,并未加参数background:true. 查原因: 同事无法登录

JAVA并发,同步锁性能测试

测试主要从运行时间差来体现,数据量越大,时间差越明显,例子如下: 1 package com.xt.thinks21_2; 2 3 /** 4 * 同步锁性能测试 5 * 6 * @author Administrator 7 * 8 */ 9 public class SynchronizedTimeTest { 10 public volatile int inc = 0; 11 12 public void increase() { 13 inc++; 14 } 15 16 public

java中多线程模拟(多生产,多消费,Lock实现同步锁,替代synchronized同步代码块)

import java.util.concurrent.locks.*; class DuckMsg{ int size;//烤鸭的大小 String id;//烤鸭的厂家和标号 DuckMsg(){ } DuckMsg(int size, String id){ this.size=size; this.id=id; } public String toString(){ return id + " 大小为:" + size; } } class Duck{ private int

【Java】多线程冲突解决——同步锁

转载请注明原文地址:http://www.cnblogs.com/ygj0930/p/5827547.html 解决并行冲突最有效的方法就是加同步锁,主要有以下几种方法: 1:动态方法同步锁:锁当前对象.即调用该方法的类对象优先执行完毕才到下一个任务. public synchronized void 方法() { } 实例代码: import java.lang.Thread.State; import org.omg.CORBA.PUBLIC_MEMBER; public class Thr

在 Windows 下用 TDM-GCC(MinGW)开发 DLL 涉及到数据同步锁及 DLL 初始化终止化函数的问题

在 Windows 下用 TDM-GCC(MinGW)开发 DLL 如果要用到数据同步锁,理论上可以采用 Windows API 提供的临界区实现(需要用到的函数有 InitializeCriticalSection.DeleteCriticalSection.EnterCriticalSection.LeaveCriticalSection),也可以采用 GCC 的 pthread 库中的 pthread mutex lock 互斥锁来实现(需要用到的函数有 pthread_mutex_ini

同步锁/互斥锁

互斥锁:是为了避免多个线程抢夺资源造成数据不准确问题而提出的,是为了限制同一时刻多个线程访问同一个数据. 首先需要了解两个概念: 1>多线程并发执行:我们都知道,如果不涉及两个线程之间传值或是共享资源的时候,多个线程之间是没有交集的,你走你的阳关道我走我的独木桥, 井水不犯河水,但是如果需要传值或是共享资源两个线程之间就有了碰头的机会.所以又出了一个线程同步的概念. 2>多线程同步执行:如果单从字面理解很难说清楚有什么区别,都是说多个线程在同一时刻各自做各自的事情,本来不同线程之间就没有什么关