Java学习 - synchronized同步机制

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量446 收藏
点赞数
分类专栏： Java 文章标签： java

1、把synchronized当作函数修饰符时，示例代码如下：

public synchronized void method(){ 
//…. 
}

这也就是同步方法，他锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，他们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却能够任意调用这个被加了 synchronized关键字的方法。

2、多线程的同步依靠的是对象锁机制，synchronized关键字的背后就是利用了封锁来实现对共享资源的互斥访问。

下面以一个简单的实例来进行对比分析。实例要完成的工作非常简单，就是创建10个线程，每个线程都打印从0到99这100个数字，我们希望线程之间不会出现交叉乱序打印，而是顺序地打印。

先来看第一段代码，这里我们在run()方法中加入了synchronized关键字，希望能对run方法进行互斥访问，但结果并不如我们希望那样，这是因为这里synchronized锁住的是this对象，即当前运行线程对象本身。代码中创建了10个线程，而每个线程都持有this对象的对象锁，这不能实现线程的同步。

package com.wolflz.java;

public class ThreadDemo {
	/**
	 * @param args
	 * @throws InterruptedException
	 */
	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; ++i) {
			new Thread(new MyThread(i)).start();
			Thread.sleep(1);
		}
	}
}

class MyThread implements java.lang.Runnable {
	private int threadId;

	public MyThread(int id) {
		this.threadId = id;
	}

	@Override
	public synchronized void run() {
		for (int i = 0; i < 100; ++i) {
			System.out.println("Thread ID: " + this.threadId + " : " + i);
		}
	}
}

从上述代码可以得知，要想实现线程的同步，则这些线程必须去竞争一个唯一的共享的对象锁。

基于这种思想，我们将第一段代码修改如下所示，在创建启动线程之前，先创建一个线程之间竞争使用的Object对象，然后将这个Object对象的引用传递给每一个线程对象的lock成员变量。这样一来，每个线程的lock成员都指向同一个Object对象。我们在run方法中，对lock对象使用synchronzied块进行局部封锁，这样就可以让线程去竞争这个唯一的共享的对象锁，从而实现同步。

package com.wolflz.java;

public class ThreadDemo {
	/**
	 * @param args
	 * @throws InterruptedException
	 */
	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);
		}
	}
}

class MyThread implements java.lang.Runnable {
	private int threadId;
	private Object lock;

	public MyThread(int id, Object obj) {
		this.threadId = id;
		this.lock = obj;
	}

	@Override
	public void run() {
		synchronized (lock) {
			for (int i = 0; i < 100; ++i) {
				System.out.println("Thread ID: " + this.threadId + " : " + i);
			}
		}
	}
}

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

package com.wolflz.java;

public class ThreadDemo {
	/**
	 * @param args
	 * @throws InterruptedException
	 */
	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; ++i) {
			new Thread(new MyThread(i)).start();
			Thread.sleep(1);
		}
	}
}

class MyThread implements java.lang.Runnable {
	private int threadId;
	private static Object lock = new Object();

	public MyThread(int id) {
		this.threadId = id;
	}

	@Override
	public void run() {
		synchronized (lock) {
			for (int i = 0; i < 100; ++i) {
				System.out.println("Thread ID: " + this.threadId + " : " + i);
			}
		}
	}
}

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

package com.wolflz.java;

public class ThreadDemo {
	/**
	 * @param args
	 * @throws InterruptedException
	 */
	public static void main(String[] args) throws InterruptedException {
		for (int i = 0; i < 10; ++i) {
			new Thread(new MyThread(i)).start();
			Thread.sleep(1);
		}
	}
}

class MyThread implements java.lang.Runnable {
	private int threadId;

	public MyThread(int id) {
		this.threadId = id;
	}

	@Override
	public void run() {
		taskHandler(this.threadId);
	}

	private static synchronized void taskHandler(int threadId) {
		for (int i = 0; i < 100; ++i) {
			System.out.println("Thread ID: " + threadId + " : " + i);
		}
	}
}

synchronized：

包括synchronized方法和synchronized块。synchronized方法使用this作为默认的“同步监视器”，而synchronized块则需自行指定。wait、notify、notifyAll必须在同步方法或块中，否则会抛出异常。

Object.wait：

要执行obj.wait，当前线程必须拥有obj的监视器(monitor)执行后会导致当前线程进入等待，直到其它线程调用obj.notify或obj.notifyAll执行后当前线程会放弃在obj上的所有同步请求(synchronizationclaims)注意只是使当前线程处于等待，但对同步方法/块的占有却释放了，所以其它线程便可以随后访问这个同步方法/块了。

Object.notify，Object.notifyAll：

要执行obj.notify、obj.notifyAll，当前线程必须拥有obj的监视器(monitor)。obj.notify会随机唤醒一个等待在obj上的线程，而obj.notifyAll却会唤醒所有等待在obj上的线程。被唤醒的线程不能马上执行，直到当前线程放弃obj的同步锁(Theawakened threads will not be able to proceed until the current threadrelinquishes the lock on this object. )，也就是当前线程离开了同步方法/块后。

创建三个线程(a线程打印字符a,b线程打印字符b,c线程打印字符c)，使三个线程协作打印出abcabcabc。

package com.wolflz.java;

public class Test {

	public static void main(String[] args) throws InterruptedException {
		Object a = new Object(), b = new Object(), c = new Object();

		Printer printerA = new Printer(c, a, "a");
		Printer printerB = new Printer(a, b, "b");
		Printer printerC = new Printer(b, c, "c");

		printerA.start();
		Thread.sleep(2000);
		printerB.start();
		Thread.sleep(2000);
		printerC.start();
	}
}

class Printer extends Thread {
	private String chr;
	private Object pre, curr;

	public Printer(Object pre, Object curr, String chr) {
		super();
		this.pre = pre;
		this.curr = curr;
		this.chr = chr;
	}

	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			synchronized (pre) {
				synchronized (curr) {
					System.out.print(chr);
					curr.notify();
				}

				try {
					pre.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		System.out.print("\n" + chr + "end");
	}
}

这个例子你可能看到过，是的，我也是网上发现的。但是你发现没，最终结果是：

abcabc
aend

bend(未出现)和cend(未出现)，为简化问题，我们不妨把for循环去掉，原理是一样的。

@Override
public void run() {
	synchronized (pre) {
		synchronized (curr) {
			System.out.print(chr);
			curr.notify();
		}
		try {
			pre.wait();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	System.out.print("\n" + chr + "end");
}

a线程执行后打印“a”，唤醒等待在a上的线程(此时其实并没有其它线程在a上等待)并在pre.wait处等待。

b线程执行后打印“b”，唤醒等待在b上的线程(此时其实并没有其它线程在b上等待)并在pre.wait处等待。

c线程执行后打印“c”，唤醒等待在c上的线程并在pre.wait处等待。请注意，等待在c上的线程被唤醒了，因此a线程继续往下执行，打印出“aend”后a线程结束。但问题是b、c线程呢？他们并没有被唤醒，因此它们始终在pre.wait处等待着！

因此我们必须为b、c设置一个出口：当i=2(其实是循环次数-1即3-1=2)的时候不执行pre.wait。

package com.wolflz.java;

public class Test {

	public static void main(String[] args) throws InterruptedException {
		Object a = new Object(), b = new Object(), c = new Object();

		Printer printerA = new Printer(c, a, "a"), printerB = new Printer(a, b,
				"b"), printerC = new Printer(b, c, "c");

		printerA.start();
		Thread.sleep(2000);
		printerB.start();
		Thread.sleep(2000);
		printerC.start();
	}
}

class Printer extends Thread {
	private String chr;
	private Object pre, curr;

	public Printer(Object pre, Object curr, String chr) {
		super();
		this.pre = pre;
		this.curr = curr;
		this.chr = chr;
	}

	@Override
	public void run() {
		for (int i = 0; i < 3; i++) {
			synchronized (pre) {
				synchronized (curr) {
					System.out.print(chr);
					curr.notify();
				}

				if (i < 2) {
					try {
						pre.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}

		System.out.print("\n" + chr + "end");
	}
}

当i=2时跳过pre.wait，程序继续执行。之后i=3，由于此时i已经不满足for循环的要求，所以循环结束，直接执行System.out.print("\n"+chr+"end")，之后线程退出。

小刚lz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习----同步代码块
hanxuya的博客
08-19 904
对于synchronized语句当Java源代码被javac编译成bytecode的时候，会在同步代码块的入口位置和退出位置分别插入monitorenter和monitorexit(2个)字节码指令。
java线程同步机制，实现同步锁
qq_39558517的博客
04-02 4067
java线程同步机制 有三种方式完成同步操作：1.同步代码块。2.同步方法。3.锁机制。 同步代码块： 格式：synchronized(同步锁){ 可能会出现线程安全问题的代码(访问了共享数据的代码) } 同步锁：对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁。 1. 锁对象，可以是任意类型。2. 多个线程对象 要使用同一把锁。（注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着） 同步方法： 当多个线程需要访问某个公共资源的时候，我们知道需要通过加锁
JAVA系列---synchronized的用法
lipviolet的博客
04-28 4668
1. 背景 1.1 多线程操作同一个对象 1.1.1 不加锁 public class HandleThread { public static void main(String[] args) { SyncThread s1 = new SyncThread(); SyncThread s2 = new SyncThread(); Thread t1 = new Thread(s1); // Thread t2 = new Threa
Java 多线程 --- 线程同步 内部锁synchronized
HelloWorld
08-07 753
synchronized 关键字 synchronized 关键字修饰静态方法 synchronized代码块 --- synchronized blocks synchronized 保证原子性, 可见性, 有序性
Java线程同步机制
高玉龙的博客
05-24 478
线程同步机制是一套用于协调线程间的数据访问及活动的机制，该机制用于保障线程安全以及实现这些线程的共同目标。 锁概述 线程安全问题的前提是多个线程并发访问共享变量。针对这个情况，将多个线程对共享变量的并发访问转换为串行访问，既一个共享数据同时只能有一个线程访问，该线程访问结束后其他线程才能访问。这个思想的具体实现就是锁。 一个线程在访问共享数据时必须申请对应的锁，获得锁以后才能访问共享数据，访问完共享数据后释放锁，其他线程才能继续申请锁。执行线程在获取锁后到释放锁之前的这段时间执行的代码被称为临界区。临界区一
java-synchronized详解.doc
05-09
总结来说，`synchronized`是Java中实现线程同步的关键机制，确保了多线程环境下的数据一致性。理解它的用法和工作原理对于编写健壮的多线程程序至关重要。正确使用`synchronized`可以帮助开发者避免竞态条件和死锁等...
24.线程的同步机制-synchronized同步语句-synchronized同步代码块的使用.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
Java并发编程系列- synchronized
06-16
总结来说，`synchronized`在Java并发编程中扮演着核心角色，它通过锁机制确保了共享资源的安全访问，解决了多线程环境下的数据一致性问题。正确理解和使用`synchronized`对于编写高效、线程安全的Java代码至关重要。
java-synchronized 嵌套使用代码详解
08-29
java-synchronized 嵌套使用是 Java 编程语言中的一种同步机制，用于解决多线程并发执行时的线程安全问题。通过使用 synchronized 关键字，可以将某个对象或代码块锁定，使得其他线程无法访问该对象或代码块，从而...
27.线程的同步机制-synchronized同步语句-synchronized代码块间的同步性.mp4
04-06
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 316
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1114
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 151
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 592
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 347
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 716
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 461
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 406
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 153
新建springboot项目找不到java版本8?
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值