第二章、(3)synchronized 同步代码块

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/u010857034/article/details/81358921

摘要:

一、synchronized 代码块中的代码是同步执行,A线程执行完才轮到B线程;不在synchronized代码块中则是异步执行。

二、synchronized(this) 和 synchronized 方法一样,锁定的是当前对象。也就是说:当多个线程同时访问 同一个 object对象的synchronized(this) 方法时,改object 对象中其他synchronized(this) 或者 synchronized 方法都会被阻塞,因为它们使用的是同一个对象锁

1. synchronized同步方法在某些情况下是有弊端的,例如 A线程调用同步方法执行一个长时间任务(方法内有部分代码B线程可以异步调用),B线程则必须等待A线程执行完同步方法才能调用。这种情况下,可以考虑使用 synchronized代码块

public class Task {
	public void doLongTimeTask() throws InterruptedException {
		for (int i = 0; i < 100; i++) {
			System.out.println("nosynchronized threadName=" + Thread.currentThread().getName() + " i=" + (i + 1));
			Thread.sleep(100);
		}
		System.out.println("-----------------------");

		synchronized (this) {
			for (int i = 0; i < 100; i++) {
				System.out.println("synchronized threadName=" + Thread.currentThread().getName() + " i=" + (i + 1));
				Thread.sleep(100);
			}
		}
	}
}
public class MyThread1 extends Thread {
	private Task task;
	public MyThread1(Task task) {
		super();
		this.task = task;
	}
	@Override
	public void run() {
		super.run();
		try {
			task.doLongTimeTask();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
public class MyThread2 extends Thread {
	private Task task;
	public MyThread2(Task task) {
		super();
		this.task = task;
	}
	@Override
	public void run() {
		super.run();
		try {
			task.doLongTimeTask();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
public class Run {
	public static void main(String[] args) {
		Task task = new Task();

		MyThread1 thread1 = new MyThread1(task);
		thread1.start();

		MyThread2 thread2 = new MyThread2(task);
		thread2.start();
	}
}

运行结果: synchronized 代码块中的代码是同步执行,A线程执行完才轮到B线程;不在synchronized代码块中则是异步执行。

2. synchronized(this):synchronized(this) 和 synchronized 方法一样,锁定的是当前对象。也就是说:当多个线程同时访问 同一个 object对象的synchronized(this) 方法时,改object 对象中其他synchronized(this) 或者 synchronized 方法都会被阻塞,因为它们使用的是同一个对象锁

public class MyThread1 extends Thread {
	private Task task;
	public MyThread1(Task task) {
		super();
		this.task = task;
	}
	@Override
	public void run() {
		super.run();
		task.doLongTimeTaskA();
	}
}
public class MyThread2 extends Thread {
	private Task task;
	public MyThread2(Task task) {
		super();
		this.task = task;
	}
	@Override
	public void run() {
		super.run();
		task.otherMethod();
	}
}
public class MyThread3 extends Thread {
	private Task task;
	public MyThread3(Task task) {
		super();
		this.task = task;
	}
	@Override
	public void run() {
		super.run();
		task.doLongTimeTaskB();
	}
}
public class Task {
	synchronized public void otherMethod() {
		System.out.println("------------------------run--otherMethod");
	}
	public void doLongTimeTaskA() {
		synchronized (this) {
			for (int i = 0; i < 1000; i++) {
				System.out.println("Task A, synchronized threadName="
						+ Thread.currentThread().getName() + " i=" + (i + 1));
			}
		}
	}
	public void doLongTimeTaskB() {
		synchronized (this) {
			for (int i = 0; i < 1000; i++) {
				System.out.println("Task B, synchronized threadName="
						+ Thread.currentThread().getName() + " i=" + (i + 1));
			}
		}
	}
}
public class Run {
	public static void main(String[] args) throws InterruptedException {
		Task task = new Task();
		MyThread1 thread1 = new MyThread1(task);
		thread1.start();
		Thread.sleep(100);

		MyThread2 thread2 = new MyThread2(task);
		thread2.start();
		MyThread3 thread3 = new MyThread3(task);
		thread3.start();
	}
}

运行结果:synchronized(this)、synchronized方法 持有同一个 object 对象,并且是阻塞运行的。

展开阅读全文

没有更多推荐了,返回首页