Java 自定义互斥锁 synchronized互斥锁

转载

编程艺术大师 2024-01-08 18:22:06

文章标签 Java 自定义互斥锁 Synchronized 同步线程安全锁 文章分类 Java 后端开发

线程安全问题的主要诱因
1、存在共享数据（也称临界资源）
2、存在多条线程共同操作这些共享数据
解决问题的根本方法：
同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再对共享数据进行操作

互斥锁的特性
互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程的协调机制，这样在同一时间只有一个线程对需要同步的代码块（复合操作）进行访问。互斥性也称为操作的原子性。
可见性：必须确保在锁被释放之前，对共享变量所作的修改，对于随后获得该锁的另一个线程是可见的（即在获得锁时应获得最新共享变量的值），否则另一个线程可能是在本地缓存的某个副本上继续操作，从而引起不一致。
synchronized锁的不是代码，锁的都是对象

根据获取的锁的分类：获取对象锁和获取类锁
获取对象锁的两种方法：
1、同步代码块（synchronized（this），synchronized（类实列对象）），锁是小括号中的实列对象。
2、同步非静态方法（synchronized method），锁是当前对象的实列对象。
获取类锁的两种方法：
1、同步代码块（synchronized （类.class）），锁是小括号（）中的类对象（Class对象）。
2、同步静态方法（synchronized static method），锁是当前对象的类对象（Class对象）。

import java.text.SimpleDateFormat;
import java.util.Date;

public class SynchronizedThread implements Runnable {
	
	public void run() {
		String threadName = Thread.currentThread().getName();
		if(threadName.startsWith("A")) {
			async();
		}else if(threadName.startsWith("B")) {
			syncObjectBlock();
		}else if(threadName.startsWith("C")) {
			syncObjectMethod();
		}
	}
	
	/**
	 * 异步方法
	 */
	private void async() {
		System.out.println(Thread.currentThread().getName() + "-已进入异步方法: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
		try {
			System.out.println(Thread.currentThread().getName() + "-异步方法执行开始: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName() + "-异步方结束执行: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
		}catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 同步代码块
	 */
	private void syncObjectBlock() {
		System.out.println(Thread.currentThread().getName() + "-已进入同步代码块: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
		synchronized (this) {
			try {
				System.out.println(Thread.currentThread().getName() + "-同步代码块执行开始: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName() + "-同步代码块执行结束: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	/**
	 * 非静态方法
	 */
	private synchronized void syncObjectMethod() {
		System.out.println(Thread.currentThread().getName() + "-已进入非静态同步方法: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
		try {
			System.out.println(Thread.currentThread().getName() + "-非静态同步方法执行开始: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
			Thread.sleep(1000);
			System.out.println(Thread.currentThread().getName() + "-非静态同步方法执行结束: " + new SimpleDateFormat("yyyy-MM-dd HH:mm:sss").format(new Date()));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

public class SyncDemo {
	public static void main(String[] args) {
		SynchronizedThread syncThread = new SynchronizedThread();
		Thread A_thread1 = new Thread(syncThread, "A_1");
		Thread A_thread2 = new Thread(syncThread, "A_2");
		Thread B_thread1 = new Thread(syncThread, "B_1");
		Thread B_thread2 = new Thread(syncThread, "B_2");
		Thread C_thread1 = new Thread(syncThread, "C_1");
		Thread C_thread2 = new Thread(syncThread, "C_2");
		A_thread1.start();
		A_thread2.start();
		B_thread1.start();
		B_thread2.start();
		C_thread1.start();
		C_thread2.start();
	}
}

打印结果

Java 自定义互斥锁 synchronized互斥锁_Java 自定义互斥锁