Java中利用synchronized关键字实现多线程同步问题 .

最新推荐文章于 2021-08-30 23:00:43 发布
最新推荐文章于 2021-08-30 23:00:43 发布
阅读量539 收藏
点赞数
分类专栏： Java 文章标签： java 多线程

    Java 中多线程的同步依靠的是对象锁机制,synchronized关键字就是利用了封装对象锁来实现对共享资源的互斥访问。
      下面以一个简单例子来说明多线程同步问题，我们希望在run()方法里加入synchronized关键字来实现互斥访问。
   
[html] view plain copy print ?
  1. package com.clark.thread;  
  2.   
  3. public class MyThread implements Runnable{  
  4.     private int threadId;  
  5.       
  6.     public MyThread(int id){  
  7.         this.threadId = id;  
  8.     }  
  9.     @Override  
  10.     public synchronized void run() {  
  11.         //此时关键字synchronized锁住的是this对象,即当前运行线程对象本身  
  12.         for (int i = 0; i < 100; i++) {  
  13.             if(i % 10 ==0){  
  14.                 System.out.println();  
  15.             }  
  16.             System.out.print("Thread ID:"+this.threadId+":"+i+" ");  
  17.         }  
  18.     }  
  19.   
  20. }  
package com.clark.thread;

public class MyThread implements Runnable{
    private int threadId;
    
    public MyThread(int id){
        this.threadId = id;
    }
    @Override
    public synchronized void run() {
        //此时关键字synchronized锁住的是this对象,即当前运行线程对象本身
        for (int i = 0; i < 100; i++) {
            if(i % 10 ==0){
                System.out.println();
            }
            System.out.print("Thread ID:"+this.threadId+":"+i+" ");
        }
    }

}
  测试类：
[html] view plain copy print ?
  1. package com.clark.thread;  
  2.   
  3. public class ThreadDemo {  
  4.     public static void main(String[] args) throws InterruptedException {  
  5.                  //代码中创建了10个线程，而每个线程都持有this对象的对象锁，这不能实现线程的同步。  
  6.                  for (int i = 0; i < 10; i++) {  
  7.             new Thread(new MyThread(i)).start();  
  8.             Thread.sleep(1);  
  9.          }  
  10.     }  
  11. }  
package com.clark.thread;

public class ThreadDemo {
	public static void main(String[] args) throws InterruptedException {
                 //代码中创建了10个线程，而每个线程都持有this对象的对象锁，这不能实现线程的同步。
                 for (int i = 0; i < 10; i++) {
			new Thread(new MyThread(i)).start();
			Thread.sleep(1);
		 }
	}
}
     打印结果部分如下:其线程不是互斥访问的。因此没有达到资源多线程同步效果。。。
[html] view plain copy print ?
  1. Thread ID:1:60 Thread ID:1:61 Thread ID:1:62 Thread ID:1:63 Thread ID:1:64 Thread ID:1:65 Thread ID:1:66 Thread ID:1:67 Thread ID:1:68 Thread ID:1:69   
  2. Thread ID:1:70 Thread ID:1:71 Thread ID:1:72 Thread ID:1:73 Thread ID:1:74 Thread ID:1:75 Thread ID:1:76   
  3. Thread ID:1:77 Thread ID:1:78 Thread ID:1:79   
  4. Thread ID:1:80 Thread ID:1:81 Thread ID:2:0 Thread ID:1:82 Thread ID:1:83 Thread ID:1:84 Thread ID:1:85 Thread ID:1:86 Thread ID:1:87 Thread ID:1:88 Thread ID:1:89   
  5. Thread ID:1:90 Thread ID:1:91 Thread ID:1:92 Thread ID:1:93 Thread ID:1:94 Thread ID:1:95 Thread ID:2:1 Thread ID:2:2 Thread ID:2:3 Thread ID:2:4 Thread ID:2:5 Thread ID:2:6 Thread ID:2:7 Thread ID:2:8 Thread ID:2:9   
Thread ID:1:60 Thread ID:1:61 Thread ID:1:62 Thread ID:1:63 Thread ID:1:64 Thread ID:1:65 Thread ID:1:66 Thread ID:1:67 Thread ID:1:68 Thread ID:1:69 
Thread ID:1:70 Thread ID:1:71 Thread ID:1:72 Thread ID:1:73 Thread ID:1:74 Thread ID:1:75 Thread ID:1:76 
Thread ID:1:77 Thread ID:1:78 Thread ID:1:79 
Thread ID:1:80 Thread ID:1:81 Thread ID:2:0 Thread ID:1:82 Thread ID:1:83 Thread ID:1:84 Thread ID:1:85 Thread ID:1:86 Thread ID:1:87 Thread ID:1:88 Thread ID:1:89 
Thread ID:1:90 Thread ID:1:91 Thread ID:1:92 Thread ID:1:93 Thread ID:1:94 Thread ID:1:95 Thread ID:2:1 Thread ID:2:2 Thread ID:2:3 Thread ID:2:4 Thread ID:2:5 Thread ID:2:6 Thread ID:2:7 Thread ID:2:8 Thread ID:2:9
从上述得知,要想实现线程同步，必须让这些线程去竞争一个唯一的共享对象锁。
[html] view plain copy print ?
  1. package com.clark.thread;  
  2.   
  3. public class MyThread implements Runnable{  
  4.     private int threadId;  
  5.     private Object object;//线程之间竞争使用的对象锁  
  6.     public MyThread(int id,Object object){  
  7.         this.threadId = id;  
  8.         this.object = object;  
  9.     }  
  10.     @Override  
  11.     public  void run() {  
  12.         /**  
  13.          * 将这个object对象的引用传递给每一个线程对象的lock成员变量  
  14.          * 从而每个线程的lock成员都指向同一个Object对象  
  15.          * 这样就可以让线程去竞争这个唯一的共享的对象锁，从而实现同步。  
  16.          */  
  17.         synchronized(object){  
  18.             for (int i = 0; i < 100; i++) {  
  19.                 if(i % 10 ==0){  
  20.                     System.out.println();  
  21.                 }  
  22.                 System.out.print("Thread ID:"+this.threadId+":"+i+" ");  
  23.             }  
  24.         }  
  25.     }  
  26.   
  27. }  
package com.clark.thread;

public class MyThread implements Runnable{
	private int threadId;
	private Object object;//线程之间竞争使用的对象锁
	public MyThread(int id,Object object){
		this.threadId = id;
		this.object = object;
	}
	@Override
	public  void run() {
		/**
		 * 将这个object对象的引用传递给每一个线程对象的lock成员变量
		 * 从而每个线程的lock成员都指向同一个Object对象
		 * 这样就可以让线程去竞争这个唯一的共享的对象锁，从而实现同步。
		 */
		synchronized(object){
			for (int i = 0; i < 100; i++) {
				if(i % 10 ==0){
					System.out.println();
				}
				System.out.print("Thread ID:"+this.threadId+":"+i+" ");
			}
		}
	}

}
[html] view plain copy print ?
  1. package com.clark.thread;  
  2.   
  3. public class ThreadDemo {  
  4.     public static void main(String[] args) throws InterruptedException {  
  5.         Object obj = new Object();  
  6.         for (int i = 0; i < 10; i++) {  
  7.             new Thread(new MyThread(i,obj)).start();  
  8.             Thread.sleep(1);  
  9.         }  
  10.     }  
  11. }  
package com.clark.thread;

public class ThreadDemo {
	public static void main(String[] args) throws InterruptedException {
		Object obj = new Object();
		for (int i = 0; i < 10; i++) {
			new Thread(new MyThread(i,obj)).start();
			Thread.sleep(1);
		}
	}
}
测试结果如下:
[html] view plain copy print ?
  1. Thread ID:5:60 Thread ID:5:61 Thread ID:5:62 Thread ID:5:63 Thread ID:5:64 Thread ID:5:65 Thread ID:5:66 Thread ID:5:67 Thread ID:5:68 Thread ID:5:69   
  2. Thread ID:5:70 Thread ID:5:71 Thread ID:5:72 Thread ID:5:73 Thread ID:5:74 Thread ID:5:75 Thread ID:5:76 Thread ID:5:77 Thread ID:5:78 Thread ID:5:79   
  3. Thread ID:5:80 Thread ID:5:81 Thread ID:5:82 Thread ID:5:83 Thread ID:5:84 Thread ID:5:85 Thread ID:5:86 Thread ID:5:87 Thread ID:5:88 Thread ID:5:89   
  4. Thread ID:5:90 Thread ID:5:91 Thread ID:5:92 Thread ID:5:93 Thread ID:5:94 Thread ID:5:95 Thread ID:5:96 Thread ID:5:97 Thread ID:5:98 Thread ID:5:99   
  5. Thread ID:6:0 Thread ID:6:1 Thread ID:6:2 Thread ID:6:3 Thread ID:6:4 Thread ID:6:5 Thread ID:6:6 Thread ID:6:7 Thread ID:6:8 Thread ID:6:9   
  6. Thread ID:6:10 Thread ID:6:11 Thread ID:6:12 Thread ID:6:13 Thread ID:6:14 Thread ID:6:15 Thread ID:6:16 Thread ID:6:17 Thread ID:6:18 Thread ID:6:19   
  7. Thread ID:6:20 Thread ID:6:21 Thread ID:6:22 Thread ID:6:23 Thread ID:6:24 Thread ID:6:25 Thread ID:6:26 Thread ID:6:27 Thread ID:6:28 Thread ID:6:29   
Thread ID:5:60 Thread ID:5:61 Thread ID:5:62 Thread ID:5:63 Thread ID:5:64 Thread ID:5:65 Thread ID:5:66 Thread ID:5:67 Thread ID:5:68 Thread ID:5:69 
Thread ID:5:70 Thread ID:5:71 Thread ID:5:72 Thread ID:5:73 Thread ID:5:74 Thread ID:5:75 Thread ID:5:76 Thread ID:5:77 Thread ID:5:78 Thread ID:5:79 
Thread ID:5:80 Thread ID:5:81 Thread ID:5:82 Thread ID:5:83 Thread ID:5:84 Thread ID:5:85 Thread ID:5:86 Thread ID:5:87 Thread ID:5:88 Thread ID:5:89 
Thread ID:5:90 Thread ID:5:91 Thread ID:5:92 Thread ID:5:93 Thread ID:5:94 Thread ID:5:95 Thread ID:5:96 Thread ID:5:97 Thread ID:5:98 Thread ID:5:99 
Thread ID:6:0 Thread ID:6:1 Thread ID:6:2 Thread ID:6:3 Thread ID:6:4 Thread ID:6:5 Thread ID:6:6 Thread ID:6:7 Thread ID:6:8 Thread ID:6:9 
Thread ID:6:10 Thread ID:6:11 Thread ID:6:12 Thread ID:6:13 Thread ID:6:14 Thread ID:6:15 Thread ID:6:16 Thread ID:6:17 Thread ID:6:18 Thread ID:6:19 
Thread ID:6:20 Thread ID:6:21 Thread ID:6:22 Thread ID:6:23 Thread ID:6:24 Thread ID:6:25 Thread ID:6:26 Thread ID:6:27 Thread ID:6:28 Thread ID:6:29

从第二段代码可知，同步的关键是多个线程对象竞争同一个共享资源即可，上面的代码中是通过外部创建共享资源，然后传递到线程中来实现。我们也可以利用类成员变量被所有类的实例所共享这一特性，因此可以将 lock 用静态成员对象来实现，代码如下所示： 修改MyThread.java类如下

[html] view plain copy print ?
  1. package com.clark.thread;  
  2.   
  3. public class MyThread implements Runnable{  
  4.     private int threadId;  
  5.     private static Object object = new Object();//线程之间竞争使用的对象锁  
  6.     public MyThread(int id){  
  7.         this.threadId = id;  
  8.     }  
  9.     @Override  
  10.     public  void run() {  
  11.         <strong>/**  
  12.          * 将这个object对象的引用传递给每一个线程对象的lock成员变量  
  13.          * 从而每个线程的lock成员都指向同一个Object对象  
  14.          * 这样就可以让线程去竞争这个唯一的共享的对象锁，从而实现同步。  
  15.          */</strong>  
  16.         synchronized(object){  
  17.             for (int i = 0; i < 100; i++) {  
  18.                 if(i % 10 ==0){  
  19.                     System.out.println();  
  20.                 }  
  21.                 System.out.print("Thread ID:"+this.threadId+":"+i+" ");  
  22.             }  
  23.         }  
  24.     }  
  25.   
  26. }  
package com.clark.thread;

public class MyThread implements Runnable{
	private int threadId;
	private static Object object = new Object();//线程之间竞争使用的对象锁
	public MyThread(int id){
		this.threadId = id;
	}
	@Override
	public  void run() {
		<strong>/**
		 * 将这个object对象的引用传递给每一个线程对象的lock成员变量
		 * 从而每个线程的lock成员都指向同一个Object对象
		 * 这样就可以让线程去竞争这个唯一的共享的对象锁，从而实现同步。
		 */</strong>
		synchronized(object){
			for (int i = 0; i < 100; i++) {
				if(i % 10 ==0){
					System.out.println();
				}
				System.out.print("Thread ID:"+this.threadId+":"+i+" ");
			}
		}
	}

}
结果如下：
[html] view plain copy print ?
  1. Thread ID:0:0 Thread ID:0:1 Thread ID:0:2 Thread ID:0:3 Thread ID:0:4 Thread ID:0:5 Thread ID:0:6 Thread ID:0:7 Thread ID:0:8 Thread ID:0:9   
  2. Thread ID:0:10 Thread ID:0:11 Thread ID:0:12 Thread ID:0:13 Thread ID:0:14 Thread ID:0:15 Thread ID:0:16 Thread ID:0:17 Thread ID:0:18 Thread ID:0:19   
  3. Thread ID:0:20 Thread ID:0:21 Thread ID:0:22 Thread ID:0:23 Thread ID:0:24 Thread ID:0:25 Thread ID:0:26 Thread ID:0:27 Thread ID:0:28 Thread ID:0:29   
  4. Thread ID:0:30 Thread ID:0:31 Thread ID:0:32 Thread ID:0:33 Thread ID:0:34 Thread ID:0:35 Thread ID:0:36 Thread ID:0:37 Thread ID:0:38 Thread ID:0:39   
Thread ID:0:0 Thread ID:0:1 Thread ID:0:2 Thread ID:0:3 Thread ID:0:4 Thread ID:0:5 Thread ID:0:6 Thread ID:0:7 Thread ID:0:8 Thread ID:0:9 
Thread ID:0:10 Thread ID:0:11 Thread ID:0:12 Thread ID:0:13 Thread ID:0:14 Thread ID:0:15 Thread ID:0:16 Thread ID:0:17 Thread ID:0:18 Thread ID:0:19 
Thread ID:0:20 Thread ID:0:21 Thread ID:0:22 Thread ID:0:23 Thread ID:0:24 Thread ID:0:25 Thread ID:0:26 Thread ID:0:27 Thread ID:0:28 Thread ID:0:29 
Thread ID:0:30 Thread ID:0:31 Thread ID:0:32 Thread ID:0:33 Thread ID:0:34 Thread ID:0:35 Thread ID:0:36 Thread ID:0:37 Thread ID:0:38 Thread ID:0:39

再来看第一段代码，实例方法中加入sychronized关键字封锁的是this对象本身，而在静态方法中加入sychronized关键字封锁的就是类本身。静态方法是所有类实例对象所共享的，因此线程对象在访问此静态方法时是互斥访问的，从而可以实现线程的同步，代码如下所示：

[html] view plain copy print ?
  1. package com.clark.thread;  
  2.   
  3. public class MyThread implements Runnable{  
  4.     private int threadId;  
  5.     public MyThread(int id){  
  6.         this.threadId = id;  
  7.     }  
  8.     @Override  
  9.     public  void run() {  
  10.         start(this.threadId);  
  11.     }  
  12.     private static synchronized void start(int threadId2) {  
  13.         for (int i = 0; i < 100; i++) {  
  14.             if(i % 10 == 0){  
  15.                 System.out.println();  
  16.             }  
  17.             System.out.print("Thread ID:"+threadId2+":"+i+" ");  
  18.         }  
  19.     }  
  20.   
  21. }  
package com.clark.thread;

public class MyThread implements Runnable{
	private int threadId;
	public MyThread(int id){
		this.threadId = id;
	}
	@Override
	public  void run() {
		start(this.threadId);
	}
	private static synchronized void start(int threadId2) {
		for (int i = 0; i < 100; i++) {
			if(i % 10 == 0){
				System.out.println();
			}
			System.out.print("Thread ID:"+threadId2+":"+i+" ");
		}
	}

}

结果如下=========

Thread ID:0:0 Thread ID:0:1 Thread ID:0:2 Thread ID:0:3 Thread ID:0:4 Thread ID:0:5 Thread ID:0:6 Thread ID:0:7 Thread ID:0:8 Thread ID:0:9 Thread ID:0:10 Thread ID:0:11 Thread ID:0:12 Thread ID:0:13 Thread ID:0:14 Thread ID:0:15 Thread ID:0:16 Thread ID:0:17 Thread ID:0:18 Thread ID:0:19 Thread ID:0:20 Thread ID:0:21 Thread ID:0:22 Thread ID:0:23 Thread ID:0:24 Thread ID:0:25 Thread ID:0:26 Thread ID:0:27 Thread ID:0:28 Thread ID:0:29 Thread ID:0:30 Thread ID:0:31 Thread ID:0:32 Thread ID:0:33 Thread ID:0:34 Thread ID:0:35 Thread ID:0:36 Thread ID:0:37 Thread ID:0:38 Thread ID:0:39 Thread ID:0:40 Thread ID:0:41 Thread ID:0:42 Thread ID:0:43 Thread ID:0:44 Thread ID:0:45 Thread ID:0:46 Thread ID:0:47 Thread ID:0:48 Thread ID:0:49 Thread ID:0:50 Thread ID:0:51 Thread ID:0:52 Thread ID:0:53 Thread ID:0:54 Thread ID:0:55 Thread ID:0:56 Thread ID:0:57 Thread ID:0:58 Thread ID:0:59

huangqiang12
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
synchronized实现线程同步
wen_wu_shuang_quan的专栏
05-06 573
多线程访问同一个变量时，如果这些线程中既有读操作，又有写操作，就会导致变量值出现混乱。这个时候应该实现线程同步。 synchronized是Java关键字，利用这个关键字可以做到线程同步。
【synchronized关键字实现线程同步及实现线程安全】
最新发布
qq_31532979的博客
01-31 805
使用线程安全的集合类：Java.util.concurrent包提供了线程安全的集合类，如ConcurrentHashMap、CopyOnWriteArrayList等。这些类使用原子操作来保证对变量的读写操作是线程安全的。使用volatile关键字：volatile关键字用于修饰变量，对于被volatile修饰的变量，线程每次读取该变量时都会从主内存中读取，而不是从线程的本地缓存中读取。使用Lock接口和它的实现类（如ReentrantLock）：Lock接口提供了更灵活和可扩展的方式来实现线程同步。
线程同步基础之使用synchronized实现同步方法
weixin_34292924的博客
05-03 131
为什么80%的码农都做不了架构师？>>> ...
多线程四 synchronized关键字解决线程同步问题
iqqcode
07-26 446
线程的同步1. java中锁的实现1.1 使用 synchroinzed 的两种用法1.2 二者之间的区别2.synchronized对象锁 多线程编程的三大问题： 分工 同步：线程间的通信 互斥：多线程并发时，某一时刻只能有一个线程访问资源 共享资源带来的并发问题（详细的分析点击文章） 12306买票 class Web123 implements Runnable { priva...
使用synchronized关键字实现线程同步
Hsiao99的博客
03-14 772
synchronized方法 声明方法时使用：public synchronized void Method(){方法体} public class testWeb12306 implements Runnable { private int ticketnums=99; boolean flag=true; @Override public void run() { ...
实例解析Java中的synchronized关键字与线程平安问题_.docx
10-09
synchronized 关键字是 Java 中解决线程同步问题的重要工具，但是需要正确的用法，否则将无法实现线程平安。在编写代码时，需要仔细考虑 synchronized 关键字的使用，以确保代码的线程平安和高效运行。 此外，...
Java中使用synchronized关键字实现简单同步操作示例
09-03
Java中的`synchronized`关键字是用于实现线程同步的关键工具，其目的是确保在多线程环境中，同一时刻只有一个线程能够执行特定的代码块或方法，从而避免数据竞争和并发问题。下面将详细介绍`synchronized`关键字的三...
【ASP.NET编程知识】实例解析Java中的synchronized关键字与线程安全问题.docx
05-21
在Java编程中，`synchronized`关键字是用来解决多线程环境下的线程安全问题的关键工具。线程安全意味着当多个线程访问同一段代码时，该代码能够正确地处理并发情况，不会出现数据不一致或者资源竞争的问题。本文将...
实例解析Java中的synchronized关键字与线程安全问题
09-02
在Java编程语言中，`synchronized`关键字是用于处理多线程环境下的线程安全问题的关键工具。它确保同一时间只有一个线程可以执行特定的代码块或方法，从而避免数据竞争和其他并发问题。本文将通过实例解析`...
Java 多线程synchronized关键字详解(六)
09-03
总的来说，`synchronized`是Java中实现线程同步的重要手段，理解其工作原理和用法对于编写安全的多线程代码至关重要。通过适当使用同步机制，开发者可以有效地控制并发，避免数据不一致性和提高程序的可靠性。
java使用synchronized实现线程同步
blue_x2的博客
08-30 316
线程同步 什么是线程同步呢？ 现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如食堂排队打饭，每个人都想吃饭，最天然的解决办法就是排队，一个一个来。 处理多线程问题，多个线程访问同一个对象，并且某些线程还想修改这些对象。这里我们就需要线程同步。线程同步就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用 队列+锁 由于同一进程的多个线程共享一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确
java中同步(synchronized)访问共享的可变数据及原子性操作
OceanSky的专栏
05-01 1446
当多个线程共享可变数据的时候，每个读或者写数据的线程都必须执行同步。如果没有同步，就无法保证一个线程所做的修改可以被另外一个线程获知。未能同步共享可变数据会造成程序的活性失败（liveness failure）和安全性失败（safety failure）。这样的失败是最难以调试的。它们可能是间歇性的，切与时间相关，程序的行为在不同的VM上可能根本不同。如果只需要线程之间的交互通信，而不需要互斥，v...
JAVA并发编程3_线程同步之synchronized关键字
weixin_30784141的博客
05-20 101
在上一篇博客里讲解了JAVA的线程的内存模型，见：JAVA并发编程2_线程安全&内存模型，接着上一篇提到的问题解决多线程共享资源的情况下的线程安全问题。 不安全线程分析 public class Test implements Runnable { private int i = 0; private int getNext() { return i++; } ...
Java 并发进阶知识之 synchronized 关键字
weixin_30502965的博客
06-24 121
synchronized 相关知识 1、synchronized 简介 synchronized 关键字解决的是多线程之间访问资源的同步性，synchronized 关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 synchronized 的以下几种最主要的使用方式： （1）、同步一个代码块 public void func() { syc...
Java使用synchronized实现多线程操作list<1>
mopei
11-27 991
Java的多线程实现方式有两种，一种是继承Thread类，一中是实现Runnable接口，这两种都要重写run方法，因为在run方法中存放的是要在多线程执行的代码，使用synchronized时要绑定一个对象，对于存在多个线程竞争的程序时就需要多个程序使用的是同一个锁资源，否则无法实现同步，具体的代码如下 下面以经典的生产者、消费者为例 生产者线程： public class Produce
java多线程-Synchronized关键字详解
lijianbiao0的博客
05-30 681
Synchronized关键字开篇定义作用应用场景原理具体使用使用方式特别注意其他控制并发 / 线程同步方式Lock、ReentrantLock简介区别Compare And Swap（CAS）定义：原理优点典型应用：AtomicInteger 开篇 在Java中，有一个常被忽略 但 非常重要的关键字Synchronized 今天，我将详细讲解 Java关键字Synchronized的所有知识，希...
同步互斥访问 - synchronized关键字
简单世界的博客
08-17 1591
java，同步互斥，synchronized
Synchronized关键字与多线程
weixin_30480651的博客
10-03 58
在java中，每一个对象有且仅有一个同步锁。这也意味着，同步锁是依赖于对象而存在。当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。例如，synchronized(obj)就获取了“obj这个对象”的同步锁。不同线程对同步锁的访问是互斥的。也就是说，某时间点，对象的同步锁只能被一个线程获取到！通过同步锁，我们就能在多线程中，实现对“对象/方法”的互斥访问。 例如，现在有两个...
【Java多线程】多线程同步——对“synchronized”关键字的简单理解
极客-多重人格递归
02-06 268
既然一个进程中可以有多个线程，并且多个线程共享资源，那么，由谁来管理这些个共享的资源，以至于不被各个线程争抢呢？

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值