Synchronized几种不同的同步方法、脏读、死锁代码样例讲解

最新推荐文章于 2023-11-16 16:51:43 发布
最新推荐文章于 2023-11-16 16:51:43 发布
阅读量434 收藏 1
点赞数
分类专栏： 锁 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/d303577562/article/details/109197169
版权

1. 方法内的变量不存在非线程安全问题，永远都是线程安全的，这是因为方法内部的变量具有私有特性，不需要使用同步。

2. 当两个线程同时访问同一个业务对象中的没有同步的方法，并且同时操作业务对象中的实例变量，则有可能出现非线程安全问题。

例子如下

public class SynchronizedTest2 {

	public static void main(String[] args) {
		HasSelfPrivateNum numRef = new HasSelfPrivateNum();
		ThreadA aThread = new ThreadA(numRef);
		aThread.start();
		ThreadB bThread = new ThreadB(numRef);
		bThread.start();
	}
	
	static class HasSelfPrivateNum{
		private int num = 0;
		public void addI(String name) {
			try {
				if("a".equals(name)) {
					num = 100;
					System.out.println("a set over!");
					Thread.sleep(2000);
				}else {
					num = 200;	
					System.out.println("b set over!");
				}
				System.out.println(name + "num=" + num);
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private HasSelfPrivateNum numRef;
		public ThreadA(HasSelfPrivateNum numRef) {
			super();
			this.numRef = numRef;
		}
		
		@Override
		public void run() {
			super.run();
			numRef.addI("a");
		}
	}

	static class ThreadB extends Thread{
		private HasSelfPrivateNum numRef;
		public ThreadB(HasSelfPrivateNum numRef) {
			super();
			this.numRef = numRef;
		}
		
		@Override
		public void run() {
			super.run();
			numRef.addI("b");
		}
	}
}

运行结果为

a set over!
b set over!
bnum=200
anum=200

3. 如果业务对象和锁对象是属于一对一的关系，每个线程执行自己所属业务对象中的同步方法，不存在争抢关系，也是不需要锁的。

例子如下

public class SynchronizedTest3 {

	public static void main(String[] args) {
		HasSelfPrivateNum numRefA = new HasSelfPrivateNum();
		HasSelfPrivateNum numRefB = new HasSelfPrivateNum();
		ThreadA aThread = new ThreadA(numRefA);
		aThread.start();
		ThreadB bThread = new ThreadB(numRefB);
		bThread.start();
	}
	
	static class HasSelfPrivateNum{
		private int num = 0;
		synchronized public void addI(String name) {
			try {
				if("a".equals(name)) {
					num = 100;
					System.out.println("a set over!");
					Thread.sleep(2000);
				}else {
					num = 200;	
					System.out.println("b set over!");
				}
				System.out.println(name + "num=" + num);
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private HasSelfPrivateNum numRef;
		public ThreadA(HasSelfPrivateNum numRef) {
			super();
			this.numRef = numRef;
		}
		
		@Override
		public void run() {
			super.run();
			numRef.addI("a");
		}
	}

	static class ThreadB extends Thread{
		private HasSelfPrivateNum numRef;
		public ThreadB(HasSelfPrivateNum numRef) {
			super();
			this.numRef = numRef;
		}
		
		@Override
		public void run() {
			super.run();
			numRef.addI("b");
		}
	}
}

运行结果为

a set over!
b set over!
bnum=200
anum=100

4. 两个线程访问同一个对象的两个方法

此时有以下结论

  1. A线程现持有object对象的Lock锁，B线程可以以异步的方式调用object对象中的非synchronized类型的方法。
  2. A线程先持有object对象的Lock锁，B线程如果在这时调用object对象中的synchronized类型的方法，则需要等待，也就是同步。
  3. 在方法声明处添加synchronized并不是锁方法，而是锁当前类的对象。
  4. 在Java中只有“当对象作为锁”这种说法，并没有“锁方法”这种说法。
  5. 在Java语言中，“锁”就是“对象”，“对象”可以映射成“锁”，哪个线程拿到这把锁，哪个线程就可以执行这个对象中的synchronized同步方法。
  6. 如果在对象中使用了synchronized关键字声明非静态方法，则对象就被当成锁。

例子1：两个线程分别调用同一个对象的同步方法和非同步方法

public class SynchronizedTest4_1 {

	public static void main(String[] args) {
		MyObject obejct = new MyObject();
		ThreadA aThread = new ThreadA(obejct);
		aThread.start();
		ThreadB bThread = new ThreadB(obejct);
		bThread.start();
	}
	
	static class MyObject{
		synchronized public void methodA() {
			try {
				System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
				Thread.sleep(5000);
				System.out.println("end endTime=" + System.currentTimeMillis());
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		public void methodB() {
			try {
				System.out.println("begin methodB threadName=" + Thread.currentThread().getName());
				Thread.sleep(5000);
				System.out.println("end endTime=" + System.currentTimeMillis());
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private MyObject object;
		public ThreadA(MyObject object) {
			super();
			this.object = object;
		}
		
		@Override
		public void run() {
			super.run();
			object.methodA();
		}
	}

	static class ThreadB extends Thread{
		private MyObject object;
		public ThreadB(MyObject object) {
			super();
			this.object = object;
		}
		
		@Override
		public void run() {
			super.run();
			object.methodB();
		}
	}
}

运行结果为

begin methodA threadName=Thread-0
begin methodB threadName=Thread-1
end endTime=1603249231399
end endTime=1603249231399

例子2：两个线程分别调用同一个对象的两个不同的同步方法

public class SynchronizedTest4_2 {

	public static void main(String[] args) {
		MyObject obejct = new MyObject();
		ThreadA aThread = new ThreadA(obejct);
		aThread.start();
		ThreadB bThread = new ThreadB(obejct);
		bThread.start();
	}
	
	static class MyObject{
		synchronized public void methodA() {
			try {
				System.out.println("begin methodA threadName=" + Thread.currentThread().getName());
				Thread.sleep(5000);
				System.out.println("end endTime=" + System.currentTimeMillis());
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		synchronized public void methodB() {
			try {
				System.out.println("begin methodB threadName=" + Thread.currentThread().getName());
				Thread.sleep(5000);
				System.out.println("end endTime=" + System.currentTimeMillis());
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private MyObject object;
		public ThreadA(MyObject object) {
			super();
			this.object = object;
		}
		
		@Override
		public void run() {
			super.run();
			object.methodA();
		}
	}

	static class ThreadB extends Thread{
		private MyObject object;
		public ThreadB(MyObject object) {
			super();
			this.object = object;
		}
		
		@Override
		public void run() {
			super.run();
			object.methodB();
		}
	}
}

运行结果为：

begin methodA threadName=Thread-0
end endTime=1603249500001
begin methodB threadName=Thread-1
end endTime=1603249505002

5. 脏读

我们有时候在赋值的方法进行了同步，但是在取值的方法没有进行同步，就有可能出现脏读（dirty read）
例子：

public class SynchronizedTest5 {

	public static void main(String[] args) {
		PublicVar publicVar = new PublicVar();
		ThreadA aThread = new ThreadA(publicVar);
		aThread.start();
		ThreadB bThread = new ThreadB(publicVar);
		bThread.start();
	}
	
	static class PublicVar{
		public String username = "A";
		public String password = "AA";
		synchronized public void setValue(String username, String password) {
			try {
				this.username = username;
				Thread.sleep(5000);
				this.password = password;
				System.out.println("setValue method thread name=" + Thread.currentThread().getName()
						+ " username" + username + " password=" + password);
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		public void getValue() {
			System.out.println("getValue method thread name=" + Thread.currentThread().getName()
					+ " username" + username + " password=" + password);
		}
	}

	static class ThreadA extends Thread{
		private PublicVar publicVar;
		public ThreadA(PublicVar publicVar) {
			super();
			this.publicVar = publicVar;
		}
		
		@Override
		public void run() {
			super.run();
			publicVar.setValue("B", "BB");
		}
	}

	static class ThreadB extends Thread{
		private PublicVar publicVar;
		public ThreadB(PublicVar publicVar) {
			super();
			this.publicVar = publicVar;
		}
		
		@Override
		public void run() {
			super.run();
			publicVar.getValue();
		}
	}
}

运行结果为：

getValue method thread name=Thread-1 usernameB password=AA
setValue method thread name=Thread-0 usernameB password=BB

6. Synchronized锁重入

“可重入锁”是指自己可以再次获取自己的内部锁。例如。一个线程获得了某个对象锁，此时这个对象锁还没有释放，当其再次想要获取这个对象锁时还是可以获取的。
并且锁重入支持继承的环境
例子

public class SynchronizedTest6 {

	public static void main(String[] args) {
		MyThreadA t1 = new MyThreadA();
		t1.start();
		
		MyThreadB t2 = new MyThreadB();
		t2.start();
	}
	
	static class Main{
		public int i = 10;
		synchronized public void operateIMainMethod() {
			try {
				i--;
				System.out.println("main pint i=" + i);
				Thread.sleep(100);

			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	static class Sub extends Main{
		public int i = 10;
		synchronized public void operateISubMethod() {
			try {
				i--;
				System.out.println("sub pint i=" + i);
				Thread.sleep(1000);
				super.operateIMainMethod();

			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	static class Sub2 extends Main{
		public int i = 10;
		synchronized public void operateISubMethod() {
			try {
				i--;
				System.out.println("sub2 pint i=" + i);
				Thread.sleep(1000);
				super.operateIMainMethod();

			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class MyThreadA extends Thread{
		@Override
		public void run() {
			Sub sub = new Sub();
			sub.operateISubMethod();
		}
	}
	
	static class MyThreadB extends Thread{
		@Override
		public void run() {
			Sub2 sub2 = new Sub2();
			sub2.operateISubMethod();
		}
	}
}

运行结果

sub pint i=9
sub2 pint i=9
main pint i=9
main pint i=9

7. 出现异常，锁会自动释放

当一个线程执行的代码出现异常时，其所持有的锁会自动释放。Thread.java类中suspend()方法和sleep(millis)方法被调用后并不释放锁。

8. 重写方法

重写方法如果不使用synchronized关键字，即是非同步方法，使用后变成同步方法。

9. 单一方法内的sychronized同步语句块

用关键字synchronized声明方法在某些情况下是有弊端的，例如：A线程调用同步方法执行一个长时间的任务，那么B线程等待的时间就比较长，这种情况可以使用synchronized同步语句块来解决，以提高运行效率。此时只有运行到同步语句块的时候才会需要获取锁，方法内的其他代码都不需要锁。
例子1：synchronized声明方法

public class Task{
	public String getData1;
	public String getData2;
	synchronized public void doLongTimeTask() {
		try {
			System.out.println("begin task");
			Thread.sleep(3000);
			getData1 = "长时间处理任务后从远程返回的值1 threadName=" 
					+ Thread.currentThread().getName();
			getData2 = "长时间处理任务后从远程返回的值2 threadName=" 
					+ Thread.currentThread().getName();
			System.out.println(getData1);
			System.out.println(getData2);
			System.out.println("end task");
		}catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

例子2：synchronized同步语句块

static class Task{
	public String getData1;
	public String getData2;
	public void doLongTimeTask() {
		try {
			System.out.println("begin task");
			Thread.sleep(3000);
			synchronized(this) {
				getData1 = "长时间处理任务后从远程返回的值1 threadName=" 
						+ Thread.currentThread().getName();
				getData2 = "长时间处理任务后从远程返回的值2 threadName=" 
						+ Thread.currentThread().getName();
				System.out.println(getData1);
				System.out.println(getData2);
				System.out.println("end task");
			}
		}catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

10. 多个synchronized同步语句块

在使用同步synchronized(this)代码块时需要注意，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对同一个object中所有其他synchronized(this)同步代码块的访问将被阻塞。
我们常用的PrintStream.println方法也是使用的同步代码块。

11. synchronized同步语句块和synchronized修饰的方法

使用synchronized(this)同步代码块将当前类的对象作为锁，使用synchronized修饰的方法也是将当前类所在的对象作为锁，都是同一把锁，所以会相互阻塞。
例子

public class SynchronizedTest11 {

	public static void main(String[] args) {
		Task task = new Task();
		ThreadA aThread = new ThreadA(task);
		aThread.start();
		ThreadB bThread = new ThreadB(task);
		bThread.start();
	}
	
	static class Task{
		public void doLongTimeTask() {
			try {
				synchronized(this) {
					System.out.println("=======run===doLongTimeTask====start");
					Thread.sleep(5000);
					System.out.println("=======run===doLongTimeTask====end");
				}
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		synchronized public void otherMethod() {
			System.out.println("-----run---otherMethod");
		}
	}

	static class ThreadA extends Thread{
		private Task task;
		public ThreadA(Task task) {
			super();
			this.task = task;
		}
		
		@Override
		public void run() {
			super.run();
			task.doLongTimeTask();
		}
	}

	static class ThreadB extends Thread{
		private Task task;
		public ThreadB(Task task) {
			super();
			this.task = task;
		}
		
		@Override
		public void run() {
			super.run();
			task.otherMethod();
		}
	}
}

运行结果：

=======run===doLongTimeTask====start
=======run===doLongTimeTask====end
-----run---otherMethod

12. 将任意对象作为锁

多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronzied(this)同步代码块时，调用的效果都是按顺序执行，即同步。
synchronized同步代码块和synchronized同步方法基本一样，都是下面两个规则：

  1. 对于其他synchronized同步方法或synchronized(this)同步代码块调用呈同步效果
  2. 同一时间只有一个线程可以执行synchronized同步方法（synchronized同步代码块）中的代码

除了使用synchronized(this)格式来创建同步代码块，其实Java还支持将“任意对象”作为锁来实现同步的功能，这个“任意对象”大多数是实例变量及方法的参数。使用格式为synchronized(非this对象)。
synchronized(非this对象X)同步代码的作用：当多个线程争抢相同的“非this对象X”的锁时，同一时间只有一个线程可以执行synchronized(非this对象X)同步代码块中的代码。
例子：

public class SynchronizedTest12 {

	public static void main(String[] args) {
		Service service = new Service();
		ThreadA aThread = new ThreadA(service);
		aThread.start();
		ThreadB bThread = new ThreadB(service);
		bThread.start();
	}
	
	static class Service{
		private String anyString = new String();
		public void a() {
			try {
				synchronized(anyString) {
					System.out.println("in synchronized anyString, threadName="
						 + Thread.currentThread().getName());
					Thread.sleep(5000);
					System.out.println("exit synchronized anyString, threadName="
					 	 + Thread.currentThread().getName());
				}
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private Service service;
		public ThreadA(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.a();
		}
	}

	static class ThreadB extends Thread{
		private Service service;
		public ThreadB(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.a();
		}
	}
}

运行结果：

in synchronized anyString, threadName=Thread-0
exit synchronized anyString, threadName=Thread-0
in synchronized anyString, threadName=Thread-1
exit synchronized anyString, threadName=Thread-1

13. 同一个对象中的不同锁

如果synchronized(对象X)中的对象不是同一个对象，那么即便在同一个对象锁，也不会产生锁竞争。
例子：

public class SynchronizedTest13 {

	public static void main(String[] args) {
		Service service = new Service();
		ThreadA aThread = new ThreadA(service);
		aThread.start();
		ThreadB bThread = new ThreadB(service);
		bThread.start();
	}
	
	static class Service{
		private String anyString = new String();
		public void a() {
			try {
				synchronized(anyString) {
					System.out.println("in a, threadName=" 
							+ Thread.currentThread().getName());
					Thread.sleep(5000);
					System.out.println("exit a, threadName=" 
							+ Thread.currentThread().getName());
				}
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		synchronized public void b() {
			System.out.println("in b, threadName=" 
					+ Thread.currentThread().getName());
		}
	}

	static class ThreadA extends Thread{
		private Service service;
		public ThreadA(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.a();
		}
	}

	static class ThreadB extends Thread{
		private Service service;
		public ThreadB(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.b();
		}
	}
}

运行结果：

in a, threadName=Thread-0
in b, threadName=Thread-1
exit a, threadName=Thread-0

14. 方法被调用时随机的

同步代码块放在非同步synchronized方法中进行声明，并不能保证调用方法的线程的执行同步顺序性，也就是线程调用方法的顺序是无序的，虽然在同步块中执行的顺序是同步的。
例子：

public class SynchronizedTest14 {

	public static void main(String[] args) {
		MyList list = new MyList();
		ThreadA aThread = new ThreadA(list);
		aThread.setName("A");
		aThread.start();
		ThreadB bThread = new ThreadB(list);
		bThread.setName("B");
		bThread.start();
	}
	
	static class MyList{
		synchronized public void add(String username) {
			System.out.println("in add,threadName=" 
					+ Thread.currentThread().getName());
			System.out.println("exit add,threadName=" 
					+ Thread.currentThread().getName());
		}
	}

	static class ThreadA extends Thread{
		private MyList list;
		public ThreadA(MyList list) {
			super();
			this.list = list;
		}
		
		@Override
		public void run() {
			super.run();
			for(int i = 1; i < 1000; i++) {
				list.add("threadA" + i);
			}
		}
	}

	static class ThreadB extends Thread{
		private MyList list;
		public ThreadB(MyList list) {
			super();
			this.list = list;
		}
		
		@Override
		public void run() {
			super.run();
			for(int i = 1; i < 1000; i++) {
				list.add("threadB" + i);
			}
		}
	}
}

运行结果太过于长，只截取部分

in add,threadName=A
exit add,threadName=A
in add,threadName=A
exit add,threadName=A
in add,threadName=A
exit add,threadName=A
in add,threadName=B
exit add,threadName=B
in add,threadName=B
exit add,threadName=B
in add,threadName=A
exit add,threadName=A
in add,threadName=A
exit add,threadName=A
in add,threadName=B
exit add,threadName=B
in add,threadName=A
exit add,threadName=A

15. 不同步导致的逻辑错误

有些方法不进行同步化，则会出现逻辑上的错误
例子如下：

public class SynchronizedTest15 {

	public static void main(String[] args) throws InterruptedException {
		MyOneList list = new MyOneList();
		ThreadA aThread = new ThreadA(list);
		aThread.setName("A");
		aThread.start();
		ThreadB bThread = new ThreadB(list);
		bThread.setName("B");
		bThread.start();
		
		Thread.sleep(6000);
		System.out.println("listSize=" + list.getSize());
	}
	
	static class MyOneList{
		private List<String> list = new ArrayList<String>();
		synchronized public void add(String data) {
			list.add(data);
		}
		synchronized public int getSize() {
			return list.size();
		}
	}
	
	static class MyService{
		public MyOneList addServiceMethod(MyOneList list, String data) {
			try {
				if(list.getSize() < 1) {
					Thread.sleep(2000);
					list.add(data);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			return list;
		}
	}

	static class ThreadA extends Thread{
		private MyOneList list;
		public ThreadA(MyOneList list) {
			super();
			this.list = list;
		}
		
		@Override
		public void run() {
			super.run();
			MyService msRef = new MyService();
			msRef.addServiceMethod(list, "A");
		}
	}

	static class ThreadB extends Thread{
		private MyOneList list;
		public ThreadB(MyOneList list) {
			super();
			this.list = list;
		}
		
		@Override
		public void run() {
			super.run();
			MyService msRef = new MyService();
			msRef.addServiceMethod(list, "B");
		}
	}
}

运行结果为

listSize=2

这就是没有对MyService.addServiceMethod()方法进行同步导致的错误

16. 静态同步方法synchronized方法和synchronized(class)代码块

关键字synchronized还可以应用在static静态方法上，如果这样写，那是对当前的*.java文件对应的Class类对象进行持锁，Class类的对象是单例的，更具体的说，在静态static方法上使用synchronized关键字声明同步方法时，使用当前静态方法所在类对应Class类的单例对象作为锁。
例子1：静态同步方法和非静态同步方法是不同的锁

public class SynchronizedTest16 {

	public static void main(String[] args) throws InterruptedException {
		Service service = new Service();
		ThreadA aThread = new ThreadA(service);
		aThread.setName("A");
		aThread.start();
		ThreadB bThread = new ThreadB(service);
		bThread.setName("B");
		bThread.start();
	}
	
	static class Service{
		synchronized public static void printA() {
			try {
				System.out.println("in A ,threadName=" + Thread.currentThread().getName());
				Thread.sleep(3000);
				System.out.println("exit A ,threadName=" + Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		synchronized public void printB() {
			try {
				System.out.println("in B ,threadName=" + Thread.currentThread().getName());
				Thread.sleep(3000);
				System.out.println("exit B ,threadName=" + Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private Service service;
		public ThreadA(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.printA();
		}
	}

	static class ThreadB extends Thread{
		private Service service;
		public ThreadB(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.printB();
		}
	}
}

运行结果

in A ,threadName=A
in A ,threadName=B
exit A ,threadName=B
exit A ,threadName=A

例子2：同一个类的不同对象的不同synchronized静态方法也是同一把锁

public class SynchronizedTest16_2 {

	public static void main(String[] args) throws InterruptedException {
		Service service1 = new Service();
		ThreadA aThread = new ThreadA(service1);
		aThread.setName("A");
		aThread.start();
		Service service2 = new Service();
		ThreadB bThread = new ThreadB(service2);
		bThread.setName("B");
		bThread.start();
	}
	
	static class Service{
		synchronized public static void printA() {
			try {
				System.out.println("in A ,threadName=" + Thread.currentThread().getName());
				Thread.sleep(3000);
				System.out.println("exit A ,threadName=" + Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		synchronized public static void printB() {
			try {
				System.out.println("in B ,threadName=" + Thread.currentThread().getName());
				Thread.sleep(3000);
				System.out.println("exit B ,threadName=" + Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private Service service;
		public ThreadA(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.printA();
		}
	}

	static class ThreadB extends Thread{
		private Service service;
		public ThreadB(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.printB();
		}
	}
}

运行结果

in A ,threadName=A
exit A ,threadName=A
in B ,threadName=B
exit B ,threadName=B

例子3：synchronized静态方法和synchronized(Class)是同一把锁

public class SynchronizedTest16_3 {

	public static void main(String[] args) throws InterruptedException {
		Service service1 = new Service();
		ThreadA aThread = new ThreadA(service1);
		aThread.setName("A");
		aThread.start();
		Service service2 = new Service();
		ThreadB bThread = new ThreadB(service2);
		bThread.setName("B");
		bThread.start();
	}
	
	static class Service{
		synchronized public static void printA() {
			try {
				System.out.println("in A ,threadName=" + Thread.currentThread().getName());
				Thread.sleep(3000);
				System.out.println("exit A ,threadName=" + Thread.currentThread().getName());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
		public void printB() {
			try {
				synchronized(Service.class) {
					System.out.println("in B ,threadName=" 
						+ Thread.currentThread().getName());
					Thread.sleep(3000);
					System.out.println("exit B ,threadName=" 
						+ Thread.currentThread().getName());
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private Service service;
		public ThreadA(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.printA();
		}
	}

	static class ThreadB extends Thread{
		private Service service;
		public ThreadB(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.printB();
		}
	}
}

运行结果

in A ,threadName=A
exit A ,threadName=A
in B ,threadName=B
exit B ,threadName=B

17. String常量池特性和同步相关问题

JVM具有String常量池的功能，当synchronized(string)同步块与String联合使用时，要注意常量池带来的一些意外。
当你传入的String的值是一样的时候，锁可能就是相同的。
例子

public class SynchronizedTest17 {

	public static void main(String[] args) throws InterruptedException {
		Service service = new Service();
		ThreadA aThread = new ThreadA(service);
		aThread.setName("A");
		aThread.start();
		ThreadB bThread = new ThreadB(service);
		bThread.setName("B");
		bThread.start();
	}
	
	static class Service{
		public static void print(String stringParam) {
			try {
				synchronized(stringParam) {
					while(true) {
						System.out.println("in print,threadName=" 
							+ Thread.currentThread().getName());
						Thread.sleep(1000);
						System.out.println("exit print,threadName=" 
							+ Thread.currentThread().getName());
					}
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	static class ThreadA extends Thread{
		private Service service;
		public ThreadA(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.print("AA");
		}
	}

	static class ThreadB extends Thread{
		private Service service;
		public ThreadB(Service service) {
			super();
			this.service = service;
		}
		
		@Override
		public void run() {
			super.run();
			service.print("AA");
		}
	}
}

截取部分运行结果：

in print,threadName=A
exit print,threadName=A
in print,threadName=A
exit print,threadName=A
in print,threadName=A
exit print,threadName=A
in print,threadName=A
exit print,threadName=A
in print,threadName=A
exit print,threadName=A
in print,threadName=A
exit print,threadName=A
in print,threadName=A
exit print,threadName=A

18. 多线程的死锁

Java线程死锁是一个经典的多线程问题，因为不同的线程都在等待根本不可能被释放的锁，从而导致所有的任务都无法继续完成。在多线程技术中，“死锁”是必须避免的，因为这会造成线程“假死”。
例子：

public class SynchronizedTest18 {

	public static void main(String[] args) throws InterruptedException {
		DealThread t1 = new DealThread();
		t1.setFlag("a");
		Thread thread1 = new Thread(t1);
		thread1.start();
		
		Thread.sleep(1000);
		
		t1.setFlag("b");
		Thread thread2 = new Thread(t1);
		thread2.start();
	}
	
	static class DealThread implements Runnable{
		public String username;
		public Object lock1 = new Object();
		public Object lock2 = new Object();
		public void setFlag(String username) {
			this.username = username;
		}
		
		@Override
		public void run() {
			if("a".equals(username)) {
				synchronized (lock1) {
					try {
						System.out.println("username= " + username);
						Thread.sleep(3000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					synchronized(lock2) {
						System.out.println("按lock1->lock2代码顺序执行了");
					}
				}
			}
			if("b".equals(username)) {
				synchronized (lock2) {
					try {
						System.out.println("username= " + username);
						Thread.sleep(3000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					
					synchronized(lock1) {
						System.out.println("按lock2->lock1代码顺序执行了");
					}
				}
			}
		}
	}
}

运行结果

username= a
username= b

总结

在这里插入图片描述

d303577562
关注
专栏目录
4.2并发常用技术点汇总
十年呵护的专栏
09-05 602
并发常用技术点汇总 开篇前 上篇对多线程设计模式做了简单讲解，本篇我们将从：JDK多任务执行框架、JDK并发数据结构、JDK并发控制方法、锁的性能和优化、无锁的并行计算、协程等6方面汇总并发编程技术点，让小伙伴学习有个总体脉络。 学习小提示：并发编程在某些高并发场景下能显著提升程序性能，本章带大家了解下并发编程方面的知识，但本小节涵盖知识点比较多，学习过程中遇到不明白知识点要及时讨论汇总。 一、JDK多任务执行框架 为了给并行程序开发提供更好的支持，Java提供了Thread类、Runnable接口
经典.net面试（net面试题汇总）20200227版本
qq_34573534的博客
02-27 8019
经典.net面试 这些是C#和ASP.NET数据库面试题。 1. 简述private、protected、public、internal 修饰符的访问权限。 答. private : 私有成员, 在类的内部才可以访问。 protected : 保护成员，该类内部和继承类中可以访问。 public : 公共成员，完全公开，没有访问限制。 internal: 在同一命名空间内可以访问...
验证synchronized锁升级时对象头变化全过程 - springboot实战电商项目mall4j
mall4j的博客
05-13 268
springboot实战电商项目mall4j （https://gitee.com/gz-yami/mall4j) java开源商城系统 验证synchronized锁升级时对象头变化全过程 jdk版本：1.8 系统：window10 64位 jvm 启动参数：-XX:BiasedLockingStartupDelay=0 （取消延迟加载偏向锁） 首先需要已知几个概念 java 非数组对象（普通对象）的内存结构 ​ 如果是 array 对象，则会再占用一个 length 空间（4 字节），记录数组的
synchronized 同步的几种方法
00's Blog
06-05 774
<br />1.synchronized是锁对象，根本不存在锁代码块的概念 <br />2.synchronized锁定的对象 <br />  <br />   (1)synchronized(obj){}-> 这个当然是锁obj <br /> 这种方式应该是最好的，效率最高，对于一个对象中有多个共享资源时很好使用。<br />   (2)public void synchronized function(){} -> 这个锁的是function这个方法所在的对象，相当于 <br />     public
synchronized 示例
学习笔记
03-26 362
<br />synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。 <br />在进一步阐述之前，我们需要明确几点：<br />A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线
synchronized同步锁的各种情况（类锁和实例锁）
热门推荐
诗水人间
12-06 12万+
synchronized特点： 在同一时刻内。只能有一个线程有锁 synchronized锁分Class锁（加了static修饰）和 Class实例锁（无static）两种 其中 Class锁 全局只有一把锁，锁实例变量 有多少个实例变量就有多少把锁 最为关键的是要搞懂synchronized修饰产生的锁在哪里。 是锁this?（this可以有多个，因为实例变量不一定相同，thi...
java笔记三——synchronized几个实例
weixin_33826609的博客
08-13 75
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/alex197963/archive/2009/08/06/4417414.aspx一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。 二、然而，当一个线程访问obje...
操作系统常见面试总结
Tsehooo的博客
07-30 2033
一、操作系统： 1.操作系统的线程和进程的区别，线程的几种状态 ① 进程和线程 进程（Process）是资源分配的基本单位，线程（Thread）是CPU调度的基本单位。 线程将进程的资源分和CPU调度分离开来。 以前进程既是资源分配又是CPU调度的基本单位，后来为了更好的利用高性能的CPU，将资源分配和CPU调度分开。因此，出现了线程。 进程和线程的联系： 一个线程只能属于一个进程，一个进程可以拥有多个线程。线程之间共享进程资源。 进程和线程的实例： 打开一个QQ，向朋友A发文字消息是一个线程，向朋友B发
面试框架题整理
Jenius87v5的博客
04-15 2万+
面试题总结 一基础部分 1.1 集合 1.1.1 fail-fast 与 fail-safe 机制有什么区别 1.1.2 说出ArrayList,Vector, LinkedList的存储性能和特性 ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦 LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要丛第一个索引开始 ArrayList和Vector都是用数组方
面试杂项
chenpeng19910926的专栏
01-17 1604
延迟消息队列的实现方式---考察架构设计和逻辑思维性--架构设计----NO； cms 垃圾回收期的高阶—答不上来 持久带是否发生fullGC ok jps----ok jstack----ok jmap jhat------dump日志，jhat 不清楚 jstat----不清楚 dump文件中的分析 jstack Dump 日志文件中的线程状态 dump 文件里，值得关注的线程状态有：...
详解Java中synchronized关键字的死锁和内存占用问题
09-02
Java的synchronized关键字用来进行线程同步操作,然而这在使用中经常会遇到一些问题,这里我们就来详解Java中synchronized关键字的死锁和内存占用问题:
并发(四)：同步一定要在同一把锁上
甘焕的博客
07-16 376
在并发编程实践中，监视器(锁)的选择大有技巧： 如果要开发扩展(继承)，监视器尽可能选择自身，或者子类能获取到的对象，否则即使加了锁，依旧会出现状态不同步的情形，看下面的例子：public class DoubleLock { private int counter = 0; /* * 每次加1 */ public void addOne() {
锁(synchronized)和死锁
最新发布
m0_74042853的博客
11-16 189
上一篇是讲述的进程和线程, 并讲述了他们之间的联系和不同之处, 多线程的存在很大程度上的解决了频繁创建销毁进程的开销过大, 但同时多线程在带来便利的同时带来了线程安全的问题, 这其中就包括我们经常能听到的死锁问题。
线程间不同synchronized方法的调用
weixin_30402085的博客
07-14 127
以前在学习java sychronized方法在县城之间的同步时，一直把注意力集中在同一个synchronized方法的同步，也就是说，以前自己只知道当一个对象获得了同步锁，并进入一个synchronized方法（比如a()）中时，另一个线程在同一个对象上不能再进入到a()方法中。今天在看wait方法时突然想到，另一个线程在同一个对象上是否可以调用这个对象上的其他synchronized方...
多线程锁synchronized多种测试案例
guochaoHNU的博客
02-10 845
1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { //TimeUnit.SECONDS.sleep(4); //即使是当前线程sleep4秒，其他线程也无法调用此类中的所有synchronized方法，因为锁就是当前调用此方法的对象，且并没有释放。 System.out.println("------sendSMS"); }
java个人学习笔记17（synchronized+同步函数+同步代码块+死锁）
......
05-07 694
1.同步函数：就是在函数上加上同步关键字（syschronized）进行修饰    同步函数使用的锁即this，调用该函数的对象(下面例子中的b)    同步有两种形式： 1）同步代码块 2）同步函数
synchronized 同步调用非同步
鑫的专栏
06-30 339
同步方法里面可以调用非同步方法 public class T1 { // 示例演示同步方法和非同步方法同时调用 synchronized void m() { System.out.println("synchronized method" + new Date()); n(); } void n() { System.out.println("not synchronized method" + new Date())
synchronized用法总结（4个案例进行说明）
陈常杰的博客
10-29 2536
由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。 需要明确的几个问题： 1、synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果 再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。 2、无
java中synchronized关键字的使用
M_Charlie的博客
05-16 604
写在前面：在做徐boss布置的并行计算作业中，遇到了一些坑，同时也有几个同学问我类似的问题，于是想写篇东西记一下。一、Synchronized关键字的用法synchronized关键字有多种用法，这里介绍用于同步方法以及同步代码块。1.同步方法       synchronized关键字可用于方法的声明中，用于同步某个方法，加了synchronized关键字的方法相当于一个临界区，同一个对象的同一...
Java多线程：Synchronized同步类方法解析
为了解决这个问题，开发者可以使用`synchronized`关键字来同步方法或者代码块，以保证在同一时刻只有一个线程能够执行特定的代码。 对于类方法（静态方法）的同步，`synchronized`关键字会锁定类的Class对象，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值