互斥锁-同步

最新推荐文章于 2023-04-25 16:11:38 发布
最新推荐文章于 2023-04-25 16:11:38 发布
阅读量360 收藏
点赞数
分类专栏： javaSE 文章标签： thread string date class action java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjp553650958/article/details/4499751
版权

 在近期一个Java项目里，我们使用Struts2来做MVC框架，有几个action里使用了static变量来做数据缓存，只有数据库有更新时才读取数据，减少对数据库的访问次数。
      首先需要理解的是, webwork和structs2都采用多线程处理action的，每用户请求将创建一个action对象；那么，这定义在action里的static变量将被多线程并发访问，这就需要同步控制。Java语言使用synchronized关键来进行处理，发现java组程序员对此理解不深或不全面，其实也不奇怪，他们大多数时间在做B/S结构的web系统，接触的机会并不多；作为一个老C++程序员，既然碰到了这个问题，就干脆把Java、Unix/Linux Pthread库，Win32三方面，对互斥锁的支持说明一下，主要是怎么理解和使用。
      这篇先说Java, 理解synchronized的作用，一定要抓住两点：
      1)  对象上的锁：一定要注意同一个对象才有效；
      2)  类范围上的锁：所有对象都有效。
      至于两种使用方法，下面的例子不厌其烦地列举正确和错误使用两种情况，完全理解了下面测试程序输出结果，你就及格了：

 --------------------------------------------------------------------------------------------------------------------------------------    
/**
 *
 * @author liangbing
 * @date Dec 26, 2008
 */
public class SyncObject {
 
 private byte[] lock = new byte[0]; // 特殊的instance变量, 同步控制作用
 
 private static byte[] allLock = new byte[0]; // 特殊的static变量, 同步控制作用

 public synchronized void doA(String str) throws InterruptedException {
  System.out.println("doA():: start:" + str);
  Thread.sleep(2000);
  System.out.println("doA():: end:" + str);
 }
 
 public synchronized void doB(String str) throws InterruptedException {
  System.out.println("doB():: start:" + str);
  Thread.sleep(2000);
  System.out.println("doB():: end:" + str);
 }
 
 public void doC(String str) throws InterruptedException {
  synchronized (this) {
   System.out.println("doC():: start:" + str);
   Thread.sleep(2000);
   System.out.println("doC():: end:" + str);
  }
 }
 
 public void doD(String str, Object locks) throws InterruptedException {
  synchronized(locks) {
   System.out.println("doD():: start:" + str);
   Thread.sleep(2000);
   System.out.println("doD():: end:" + str);
  }
 }
 
 public void doE(String str) throws InterruptedException {
  synchronized(lock) {
   System.out.println("doE():: start:" + str);
   Thread.sleep(2000);
   System.out.println("doE():: end:" + str);
  }
 }
 
 public synchronized static void doF(String str) throws InterruptedException {
  System.out.println("doF():: start:" + str);
  Thread.sleep(2000);
  System.out.println("doF():: end:" + str);
 }
 
 public void doG(String str) throws InterruptedException {
  synchronized (SyncObject.class) {
   System.out.println("doG():: start:" + str);
   Thread.sleep(2000);
   System.out.println("doG():: end:" + str);
  }
 }
 
 public void doH(String str) throws InterruptedException {
  synchronized (allLock) {
   System.out.println("doG():: start:" + str);
   Thread.sleep(2000);
   System.out.println("doG():: end:" + str);
  }
 }
}


 --------------------------------------------------------------------------------------------------------------------------------------

/**
 *
 * @author liangbing
 * @date Dec 26, 2008
 */
public class TestSync implements Runnable {
 
 private SyncObject ts = null;
 
 private String tag = null;
 
 public TestSync(SyncObject ts, String tag) {
  this.ts = ts;
  this.tag = tag;
 }

 public void run() {
  System.out.println("run.....");
  try {
   ts.doA(tag);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) {
  test1();
  //test2();
 }
 
 private static void test1() {
  SyncObject so = new SyncObject();
  TestSync a = new TestSync(so, "a");
  TestSync b = new TestSync(so, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
 
 private static void test2() {
  SyncObject so1 = new SyncObject();
  SyncObject so2 = new SyncObject();
  TestSync a = new TestSync(so1, "a");
  TestSync b = new TestSync(so2, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
}

--------------------------------------------------------------------------------------------------------------------------------------
/**
 *
 * @author liangbing
 * @date Dec 26, 2008
 */
public class TestSync1 implements Runnable {

 private SyncObject ts = null;
 
 private String tag = null;
 
 public TestSync1(SyncObject ts, String tag) {
  this.ts = ts;
  this.tag = tag;
 }

 public void run() {
  System.out.println("run.....");
  try {
   ts.doB(tag);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) {
  //test1();
  test2();
 }

 private static void test1() {
  SyncObject so = new SyncObject();
  TestSync a = new TestSync(so, "a");
  TestSync1 b = new TestSync1(so, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
 
 private static void test2() {
  SyncObject so1 = new SyncObject();
  SyncObject so2 = new SyncObject();
  TestSync a = new TestSync(so1, "a");
  TestSync1 b = new TestSync1(so2, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
}

--------------------------------------------------------------------------------------------------------------------------------------
/**
 *
 * @author liangbing
 * @date Dec 26, 2008
 */
public class TestSync2 implements Runnable {

 private SyncObject ts = null;
 
 private String tag = null;
 
 public TestSync2(SyncObject ts, String tag) {
  this.ts = ts;
  this.tag = tag;
 }

 public void run() {
  System.out.println("run.....");
  try {
   ts.doC(tag);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) {
  test1();
 }
 
 private static void test1() {
  SyncObject so = new SyncObject();
  TestSync a = new TestSync(so, "a");
  TestSync1 b = new TestSync1(so, "b");
  TestSync2 c = new TestSync2(so, "c");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  Thread tc = new Thread(c);
  ta.start();
  tb.start();
  tc.start();
 }
}

--------------------------------------------------------------------------------------------------------------------------------------
/**
 *
 * @author liangbing
 * @date Dec 29, 2008
 */
public class TestSync3 implements Runnable {

private SyncObject ts = null;
 
 private String tag = null;
 
 private Object lock = null;
 
 public TestSync3(SyncObject ts, String tag, Object lock) {
  this.ts = ts;
  this.tag = tag;
  this.lock = lock;
 }

 public void run() {
  System.out.println("run.....");
  try {
   ts.doD(tag, lock);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) {
  //test1();
  //test2();
  //test3();
  test4();
 }

 private static void test1() {
  SyncObject so = new SyncObject();
  String lock = "";
  TestSync3 a = new TestSync3(so, "a", lock);
  TestSync3 b = new TestSync3(so, "b", lock);
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
 
 private static void test2() {
  SyncObject so = new SyncObject();
  String lock1 = "L1";
  String lock2 = "L2";
  TestSync3 a = new TestSync3(so, "a", lock1);
  TestSync3 b = new TestSync3(so, "b", lock2);
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
 
 private static void test3() {
  SyncObject so = new SyncObject();
  String lock1 = "";
  String lock2 = "";
  TestSync3 a = new TestSync3(so, "a", lock1);
  TestSync3 b = new TestSync3(so, "b", lock2);
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
 
 private static void test4() {
  SyncObject so = new SyncObject();
  String lock1 = "L1";
  String lock2 = "L1";
  TestSync3 a = new TestSync3(so, "a", lock1);
  TestSync3 b = new TestSync3(so, "b", lock2);
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
}

--------------------------------------------------------------------------------------------------------------------------------------
/**
 *
 * @author liangbing
 * @date Dec 29, 2008
 */
public class TestSync4 implements Runnable {

 private SyncObject ts = null;
 
 private String tag = null;
 
 public TestSync4(SyncObject ts, String tag) {
  this.ts = ts;
  this.tag = tag;
 }

 public void run() {
  System.out.println("run.....");
  try {
   ts.doE(tag);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) {
  //test1();
  test2();
 }
 
 /**
  * 可以同步，同一个对象
  */
 private static void test1() {
  SyncObject so = new SyncObject();
  TestSync4 a = new TestSync4(so, "a");
  TestSync4 b = new TestSync4(so, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
 
 /**
  * 不能同步，因为不是同一个对象
  */
 private static void test2() {
  SyncObject so1 = new SyncObject();
  SyncObject so2 = new SyncObject();
  TestSync4 a = new TestSync4(so1, "a");
  TestSync4 b = new TestSync4(so2, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
}

--------------------------------------------------------------------------------------------------------------------------------------
/**
 *
 * @author liangbing
 * @date Dec 29, 2008
 */
public class TestSync5 implements Runnable {

 private String tag = null;
 
 public TestSync5(String tag) {
  this.tag = tag;
 }

 public void run() {
  System.out.println("run.....");
  try {
   SyncObject.doF(tag);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) {
  test1();
 }
 
 private static void test1() {
  TestSync5 a = new TestSync5("a");
  TestSync5 b = new TestSync5("b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
}

--------------------------------------------------------------------------------------------------------------------------------------
/**
 *
 * @author liangbing
 * @date Dec 30, 2008
 */
public class TestSync6 implements Runnable {

 private SyncObject ts = null;
 
 private String tag = null;
 
 public TestSync6(SyncObject ts, String tag) {
  this.ts = ts;
  this.tag = tag;
 }

 public void run() {
  System.out.println("run.....");
  try {
   ts.doG(tag);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) {
  //test1();
  test2();
 }
 
 private static void test1() {
  SyncObject so = new SyncObject();
  TestSync6 a = new TestSync6(so, "a");
  TestSync6 b = new TestSync6(so, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
 
 private static void test2() {
  SyncObject so1 = new SyncObject();
  SyncObject so2 = new SyncObject();
  TestSync6 a = new TestSync6(so1, "a");
  TestSync6 b = new TestSync6(so2, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
}

--------------------------------------------------------------------------------------------------------------------------------------
/**
 *
 * @author liangbing
 * @date Dec 30, 2008
 */
public class TestSync7 implements Runnable {

 private SyncObject ts = null;
 
 private String tag = null;
 
 public TestSync7(SyncObject ts, String tag) {
  this.ts = ts;
  this.tag = tag;
 }

 public void run() {
  System.out.println("run.....");
  try {
   ts.doH(tag);
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
 }
 
 public static void main(String[] args) {
  //test1();
  test2();
 }
 
 /**
  * 可以同步，static对象
  */
 private static void test1() {
  SyncObject so = new SyncObject();
  TestSync7 a = new TestSync7(so, "a");
  TestSync7 b = new TestSync7(so, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
 
 /**
  * 可以同步，static对象
  */
 private static void test2() {
  SyncObject so1 = new SyncObject();
  SyncObject so2 = new SyncObject();
  TestSync7 a = new TestSync7(so1, "a");
  TestSync7 b = new TestSync7(so2, "b");
  Thread ta = new Thread(a);
  Thread tb = new Thread(b);
  ta.start();
  tb.start();
 }
}

 

wjp553650958
关注
专栏目录
php 多线程 互斥 锁,互斥锁- pthread_mutex(示例代码)
weixin_39871162的博客
03-18 512
一. 什么是互斥锁计算机中，当多个进程或者线程共享一个临界区(例如：共享内存空间或者全局变量)，如果仅对该临界区读取，不进行内容修改，即使同时多次读取都是没有问题的。但是，当我们需要修改临界区内的内容时，我们就必须面对一个情况：同时有多个操作对临界区的内容进行修改，在操作完后，保留的是那一次操作的结果？为了解决这个问题，可以规定对临界区的修改操作，同时最多只能有一个来修改。程序中实现的方法之一就是...
09-同步概念、互斥锁解决资源竞争的问题.flv
01-21
学习python多任务
同步锁/互斥锁
dianyuxing0624的博客
11-13 185
互斥锁:是为了避免多个线程抢夺资源造成数据不准确问题而提出的,是为了限制同一时刻多个线程访问同一个数据. 首先需要了解两个概念: 1>多线程并发执行:我们都知道,如果不涉及两个线程之间传值或是共享资源的时候,多个线程之间是没有交集的,你走你的阳关道我走我的独木桥,井水不犯河水,但是如果需要传值或是共享资源两个线程之间就有了碰头的机会.所以又出了一个线程同步的概念. 2&gt...
同步互斥锁
sukiki09的博客
02-05 471
互斥锁 对于互斥锁，有两种状态：加锁和解锁 互斥锁在访问共享资源之前进行加锁，在访问结束后进行解锁 加锁后，对于其他访问共享资源的线程，会被阻塞，直到解锁 阻塞后会立刻释放CPU资源 读写锁 读写锁相比于互斥锁有更多的加锁状态：读时加锁，写时加锁，不加锁 同时只能有一个线程占有写锁，但是可以有多个线程占用读锁（写只能一个，读可以多个） 如果有线程进行读操作，则允许其他线程也进行读操作，但是不..
05 锁 同步 互斥锁
weixin_30875157的博客
01-14 78
from multiprocessing import Queue import queue import time from threading import Lock,Thread num = 100 def f1(loc): # num -= 1 loc.acquire() global num # num -= 1 tmp...
线程同步—互斥锁
a0408152的博客
02-03 403
个人总结，请各位审慎的，批判着看。 　　当两个线程访问共享数据时，可以用互斥锁来进行同步。先看一个例子: 　　该程序有两个线程，一个用来从键盘读取输入的数据，一个把读取的数据显示出来。其中，数组buffer为两个线程的共享数据。 　　编译：gcc mutex_pthread.c  -lpthread，不要忘记-lpthread。 　　运行该程序，在键盘上输入数据，然后把数据显示出来。读
互斥锁---线程的同步与互斥
fern_girl的博客
03-31 373
前面我们验证了互斥锁能够保证线程的互斥操作，让各线程对全局变量的累加的次数保证了正确性线程—中互斥锁的接口函数 互斥锁的初始化以及销毁函数： 初始化互斥锁有两种方式，一种是函数初始化，参数arr表示的是mutex的属性，一般为NULL，设置为默认属性；另一种是直接定义一个全局变量，并用宏PTHREAD_MUTEX_INITIALIZER初始化该变量。互斥锁的“加锁”和“解锁”函数 这里
多线程并发编程-同步与互斥-原⼦变量-并发和⽆锁 数据结构
最新发布
12-30
信号灯、互斥量、自旋锁和条件变量等都是实现线程同步和互斥的机制。线程同步和互斥的机制可以通过原子变量来实现。 5.3 线程同步和互斥 线程同步和互斥是多线程编程的核心技术之一。信号灯、互斥量、自旋锁和条件...
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
04-03
linux无亲缘关系间进程同步通信实现（互斥锁+条件变量+共享内存模式）
进程同步互斥--不死锁哲学家问题
06-11
进程同步互斥——不死锁哲学家问题 java实现。计算机系统原理，课程设计，(1)利用进程并发执行原理，采用奇数号哲学家先拿左叉子，偶数号哲学家先拿右叉子的算法解决哲学家就餐问题。 (2)利用java中Swing技术将...
线程互斥和同步-- 互斥锁
NeilZhy
08-04 2542
一. 线程分离 我们一般创建的线程是可结合的，这个时候如果我们调用pthread_jion()去等待的话，这种等待的方式是阻塞式等待，如果主线程一直等待，主线程就无法做其他的事情了，所以应该使用线程分离，让子线程由操作系统回收，主线程就不管了。 不管线程是否分离，它始终是在进程的内部执行的。 使用的函数接口是pthread_detach(pthread_t pid) 如果分
线程同步方式之一互斥锁
m0_61780496的博客
04-25 1469
线程同步的4种方式：互斥锁、条件变量、读写锁、信号量。以多线程购票的案例讲解互斥锁在线程同步中的应用。介绍临界资源、互斥、临界区、原子性等概念。死锁概念介绍，避免死锁的办法，可重入与线程安全的联系与区别
简单多线程同步--互斥锁
BLSpan的博客
05-30 682
/* 名称：多线程通信中同步–互斥锁 说明：多线程由于共享一部分数据段，所以当不同的线程对这部分数据进行访问的时候，就需要进行同步。以防出现数据的不一致。就我现在了解，线程中的同步有两种方式，一是这里的互斥锁，二是信号量。互斥锁，通俗说，就是只有当线程拿到这把锁之后才能进行一系列操作（包括对互斥变量的操作）。在这期间其他进程由于没有锁，只能陷入阻塞等待状态。当完成操作后，线程需要
多线程的同步与互斥（互斥锁、条件变量、读写锁、自旋锁、信号量）
my8688的专栏
12-22 1081
1. 同步与互斥的概念   现代操作系统基本都是多任务操作系统，即同时有大量可调度实体在运行。在多任务操作系统中，同时运行的多个任务可能： 都需要访问/使用同一种资源； 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务。 【同步】：   是指散布在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：...
线程同步互斥机制--互斥锁
m0_65731372的博客
10-20 6792
并发的线程访问了相同的资源，所以造成了数据的不确定性。因此，线程的通信需要结合一些同步互斥机制一起使用
C++ 线程同步之互斥锁
喜欢打篮球的普通人
06-19 6106
进行多线程编程，如果多个线程需要对同一块内存进行操作，比如：同时读、同时写、同时读写，对于后两种情况来说，如果不做任何的人为干涉就会出现各种各样的错误数据。解决多线程数据混乱的方案就是进行线程同步，最常用的就是互斥锁，在 C++11 中一共提供了四种互斥锁：不论是在 C 还是 C++ 中，进行线程同步的处理流程基本上是一致的，C++ 的 mutex 类提供了相关的 API 函数：成员函数 独占互斥锁对象有两种状态：锁定和未锁定。 除了使用 lock() 还可以使用 try_lock() 获取互斥锁
【线程同步2】使用互斥锁实现线程同步
weixin_50941083的博客
05-23 818
文章目录互斥锁基本概念互斥锁相关函数互斥锁的使用静态互斥锁的使用动态互斥锁的使用C++11标准库中的mutex生产者-消费者实现 互斥锁基本概念 互斥锁是一种使用频繁的同步手段，也被称为互斥量。对比信号量的使用，我们可以将互斥锁的使用理解为信号量初值仅为1的一种情况。 互斥锁是属于系统的内核级对象，它能够使线程拥有某个资源的绝对访问权，互斥锁主要包括使用数量、线程ID，递归计数器等，其中线程ID表示当前拥有互斥锁的线程，递归计数器表示线程拥有互斥锁的次数。 当互斥锁的线程ID为0时，表示互斥锁不被任何线
互斥锁，同步锁，临界区，互斥量，信号量，自旋锁之间联系
三余丨无梦生
03-15 1435
互斥锁和互斥量在我的理解里没啥区别，不同叫法。广义上讲可以值所有实现互斥作用的同步机制。狭义上讲指的就是mutex这种特定的二元锁机制。互斥锁的作用就是互斥，mutual exclusive，是用来保护临界区(critical section)的。所谓临界区就是代码的一个区间，如果两个线程同时执行就有可能出问题，所以需要互斥锁来保护。信号量（semaphore）是一种更高级的同步机制，mutex可...
线程同步---互斥锁和读写锁
一条二哈
01-09 1468
同步概念 所谓同步，即同时起步，协调一致。不同的对象，对“同步”的理解方式略有不同。如，设备同步，是指在两个设备之间规定一个共同的时间参考；数据库同步，是指让两个或多个数据库内容保持一致，或者按需要部分保持一致；文件同步，是指让两个或多个文件夹里的文件保持一致。等等 但是在编程中、通信中所说的同步与生活中大家印象中的同步概念略有差异。“同”字应是指协同、协助、互相配合。主旨在协同步调，按预定的先...
互斥锁应用：多线程同步示例
在这个例子中，我们关注的核心知识点是互斥锁（Mutex Lock），它是多线程编程中的一种同步机制，用于保护共享资源不被多个线程同时访问。互斥锁确保了在同一时刻只有一个线程可以持有锁并执行特定代码段，其他线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值