Java多线程笔记（二）--synchronized同步方法

最新推荐文章于 2022-05-04 15:42:45 发布
最新推荐文章于 2022-05-04 15:42:45 发布
阅读量296 收藏 1
点赞数 2
分类专栏： java 程序员的成长课 文章标签： Java多线程笔记（二）--synchronized同步方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Little_Red_Rose/article/details/96772430
版权

Java多线程笔记（二）

亲爱的观众朋友们，你们好！这是多线程笔记的第二篇文章，这一章主要是学习一下对象以及变量的并发访问。
学习完本章主要掌握以下技术点：

  • synchronized对象监视器Object时的使用。
  • synchronized对象监视器Class时的使用。
  • 非线程安全是如何出现的。
  • 关键字volatile的主要作用。
  • 关键字volatile与 synchronized的区别以及使用情况。

本章的类容较多，计划分三次更新，每次更新一部分。

1. synchronized同步方法

1.1 方法内的变量为线程安全

“非线程安全”问题存在于“实例变量”中，如果是方法内部的私有变量，则不存在“非线程安全问题。”

public class HasSelfPrivateNum {

	public void addI(String username) {
		try {
			int num = 0;
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num=" + num);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

public class ThreadA extends Thread {

	private HasSelfPrivateNum numRef;

	public ThreadA(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}

	@Override
	public void run() {
		super.run();
		numRef.addI("a");
	}

}

public class ThreadA extends Thread {

	private HasSelfPrivateNum numRef;

	public ThreadA(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}

	@Override
	public void run() {
		super.run();
		numRef.addI("a");
	}

}

public class Run {

	public static void main(String[] args) {

		HasSelfPrivateNum numRef = new HasSelfPrivateNum();

		ThreadA athread = new ThreadA(numRef);
		athread.start();

		ThreadB bthread = new ThreadB(numRef);
		bthread.start();

	}

}

int num = 0;

num变量为方法内私有变量，不存在线程安全问题！

运行结果为：

a set over！
b set over！
a num=100
b num=200

1.2 实例变量非线程安全

如果多个线程共同访问1个对象中的实例变量，则有可能出现“非线程安全问题”。

public class HasSelfPrivateNum {

	private int num = 0;

	public void addI(String username) {
		try {
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num=" + num);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

public class ThreadA extends Thread {

	private HasSelfPrivateNum numRef;

	public ThreadA(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}

	@Override
	public void run() {
		super.run();
		numRef.addI("a");
	}

}

public class ThreadB extends Thread {

	private HasSelfPrivateNum numRef;

	public ThreadB(HasSelfPrivateNum numRef) {
		super();
		this.numRef = numRef;
	}

	@Override
	public void run() {
		super.run();
		numRef.addI("b");
	}

}

public class Run {

	public static void main(String[] args) {

		HasSelfPrivateNum numRef = new HasSelfPrivateNum();

		ThreadA athread = new ThreadA(numRef);
		athread.start();

		ThreadB bthread = new ThreadB(numRef);
		bthread.start();

	}

}

结果如下：

a set over！
b set over！
a num=200
b num=200

上面这个例子中就会出现数据覆盖的情况，不是线程安全的！做修改后，就可以了！

public class HasSelfPrivateNum {

	private int num = 0;

	synchronized public void addI(String username) {
		try {
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num=" + num);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

运行结果：
a set over!
a num=100
b set over!
b num=200

两个线程访问同一个对象中的同步方法时一定是线程安全的！

1.3 多个对象多个锁
public class HasSelfPrivateNum {

	private int num = 0;

	synchronized public void addI(String username) {
		try {
			if (username.equals("a")) {
				num = 100;
				System.out.println("a set over!");
				Thread.sleep(2000);
			} else {
				num = 200;
				System.out.println("b set over!");
			}
			System.out.println(username + " num=" + num);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

ThreadA与ThreadB唯有变化

public class Run {

	public static void main(String[] args) {

		HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
		HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();

		ThreadA athread = new ThreadA(numRef1);
		athread.start();

		ThreadB bthread = new ThreadB(numRef2);
		bthread.start();

	}

}

运行结果：

a set over!
b set over!
b num=200
a num=100

从执行结果上看是异步的。

关键字synchronized获取的锁都是对象锁，而不是一段代码或者方法当作锁，先执行带synchronized关键字的线程持有方法所属对象的Lock，其他线程只能等待，前提是多个线程访问的是同一个对象。

1.4chronized方法与对象锁
public class MyObject {

	synchronized public void methodA() {
		try {
			System.out.println("begin methodA threadName="
					+ Thread.currentThread().getName());
			Thread.sleep(5000);
			System.out.println("end");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

public class ThreadA extends Thread {

	private MyObject object;

	public ThreadA(MyObject object) {
		super();
		this.object = object;
	}

	@Override
	public void run() {
		super.run();
		object.methodA();
	}

}

public class ThreadB extends Thread {

	private MyObject object;

	public ThreadB(MyObject object) {
		super();
		this.object = object;
	}

	@Override
	public void run() {
		super.run();
		object.methodA();
	}
}

public class Run {

	public static void main(String[] args) {
		MyObject object = new MyObject();
		ThreadA a = new ThreadA(object);
		a.setName("A");
		ThreadB b = new ThreadB(object);
		b.setName("B");

		a.start();
		b.start();
	}

}

在methodA()方法前加入synchronized关键字前后的运行结果如下：

begin methodA threadName=A
begin methodA threadName=B
end
end

begin methodA threadName=A
end
begin methodA threadName=B
end

调用关键字synchronized声明的方法一定是排队运行的；只有共享资源的访问才需要同步化。

public 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() + " begin time="
					+ System.currentTimeMillis());
			Thread.sleep(5000);
			System.out.println("end");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

public class ThreadA extends Thread {

	private MyObject object;

	public ThreadA(MyObject object) {
		super();
		this.object = object;
	}

	@Override
	public void run() {
		super.run();
		object.methodA();
	}

}

public class ThreadB extends Thread {

	private MyObject object;

	public ThreadB(MyObject object) {
		super();
		this.object = object;
	}

	@Override
	public void run() {
		super.run();
		object.methodB();
	}
}

public class Run {

	public static void main(String[] args) {
		MyObject object = new MyObject();
		ThreadA a = new ThreadA(object);
		a.setName("A");
		ThreadB b = new ThreadB(object);
		b.setName("B");

		a.start();
		b.start();
	}

}

methodB()方法加上synchronized前后，运行结果如下：

begin methodA threadName=A
begin methodA threadName=B begin time=1403574891268
end
end endTime=1403574896269

begin methodA threadName=A
end endTime=1403575081547
begin methodA threadName=B begin time=1403575081547
end

A线程先持有object对象的锁，B线程可以以异步的方式调用object的非synchronized方法
A线程先持有object对象的锁，B线程可以以异步的方式调用object的synchronized方法则需要等待，也就是同步。

1.5 脏读

脏读–读取实例变量时，此值已经被其他线程更改过了。

public 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();
		}
	}

	synchronized public void getValue() {
		System.out.println("getValue method thread name="
				+ Thread.currentThread().getName() + " username=" + username
				+ " password=" + password);
	}
}

public 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");
	}
}

public class Test {

	public static void main(String[] args) {
		try {
			PublicVar publicVarRef = new PublicVar();
			ThreadA thread = new ThreadA(publicVarRef);
			thread.start();

			Thread.sleep(200);// 

			publicVarRef.getValue();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

出现脏读是因为public void getValue() 不是同步的，加上synchronized关键字前后的运行结果如下：

getValue method thread name=main username=B password=AA
setValue method thread name=Thread-0 username=B password=BB

setValue method thread name=Thread-0 username=B password=BB
getValue method thread name=main username=B password=BB

1.6 synchronized锁重入

当一个线程得到一个对象锁后，再次请求该对象的锁时，是可以再次得到次对象的锁的。

public class Service {

	synchronized public void service1() {
		System.out.println("service1");
		service2();
	}

	synchronized public void service2() {
		System.out.println("service2");
		service3();
	}

	synchronized public void service3() {
		System.out.println("service3");
	}

}


public class MyThread extends Thread {
	@Override
	public void run() {
		Service service = new Service();
		service.service1();
	}

}

public class Run {
	public static void main(String[] args) {
		MyThread t = new MyThread();
		t.start();
	}
}

运行结果如下：

service1
service2
service3

可重入锁–自己可以再次获取自己的内部锁。比如一个线程获取了一个对象锁，此时还未释放锁当其再次想获取该对象的锁时还是可以获取的，不然的话会造成死锁。

可重入锁支持在父子继承的环境中。

public class Main {

	public int i = 10;

	synchronized public void operateIMainMethod() {
		try {
			i--;
			System.out.println("main print i=" + i);
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

public class Sub extends Main {

	synchronized public void operateISubMethod() {
		try {
			while (i > 0) {
				i--;
				System.out.println("sub print i=" + i);
				Thread.sleep(100);
				this.operateIMainMethod();
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

public class MyThread extends Thread {
	@Override
	public void run() {
		Sub sub = new Sub();
		sub.operateISubMethod();
	}

}

public class Run {
	public static void main(String[] args) {
		MyThread t = new MyThread();
		t.start();
	}
}

运行结果如下：
sub print i=9
main print i=8
sub print i=7
main print i=6
…

子类是完全可以通过“可重入锁”调用父类的同步方法！

1.7 出现异常，锁自动释放

当一个线程执行的代码出现异常的时候，其所持有的锁会自动释放。不影响其他线程的执行。

1.8 同步不具有继承性
public class Main {

	synchronized public void serviceMethod() {
		try {
			System.out.println("int main 下一步sleep begin threadName="
					+ Thread.currentThread().getName() + " time="
					+ System.currentTimeMillis());
			Thread.sleep(5000);
			System.out.println("int main 下一步sleep   end threadName="
					+ Thread.currentThread().getName() + " time="
					+ System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

public class Sub extends Main {

	@Override
	synchronized public void serviceMethod() {
		try {
			System.out.println("int sub 下一步isleep begin  threadName="
					+ Thread.currentThread().getName() + " time="
					+ System.currentTimeMillis());
			Thread.sleep(5000);
			System.out.println("int sub 下一步sleep   end threadName="
					+ Thread.currentThread().getName() + " time="
					+ System.currentTimeMillis());
			super.serviceMethod();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

public class MyThreadA extends Thread {

	private Sub sub;

	public MyThreadA(Sub sub) {
		super();
		this.sub = sub;
	}

	@Override
	public void run() {
		sub.serviceMethod();
	}

}
public class MyThreadB extends Thread {

	private Sub sub;

	public MyThreadB(Sub sub) {
		super();
		this.sub = sub;
	}

	@Override
	public void run() {
		sub.serviceMethod();
	}
}


public class Test {

	public static void main(String[] args) {
		Sub subRef = new Sub();

		MyThreadA a = new MyThreadA(subRef);
		a.setName("A");
		a.start();

		MyThreadB b = new MyThreadB(subRef);
		b.setName("B");
		b.start();
	}

}

子类的方法再加入synchronized前后的运行结果如下：

int sub 下一步 sleep begin in threadName=A time=1405324477242
int sub 下一步 sleep begin in threadName=B time=1405324477242
…

int sub 下一步 sleep begin in threadName=A time=1405324477242
int sub 下一步 sleep end threadName=B time=1405324477242
…

可以看出继承后重写的方法是不能继承同步属性的，需要重新声明。

最后请各位大佬激情支持！

伟大的华仔
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
synchronized同步方法
Waiting_Mr_Liu的博客
08-17 581
2.3. synchronized同步方法 2.3.1. synchronized方法的锁对象 1）先持有先运行 Synchronized取得的锁都是对象锁，而不是把一段代码/方法作为锁，因此在多线程中，哪个线程先执行带有synchronized关键字修饰的方法，哪个方法就持有该方法所属对象的锁，其他线程只能呈等待状态。但是，前提是：多个线程访问的是同一个对象，如果多个线程访问的不是同一个对象，JVM则会创建出多个对象锁。 样例代码： public class MultiObjectLock { p
JAVA并发编程实践-线程安全-学习笔记
最新发布
07-20
在Java并发编程中，线程安全是一个至关重要的概念，它涉及到多线程环境下对共享数据的正确管理和访问。线程安全意味着当多个线程同时访问一个对象或数据时，对象的状态能够保持一致性和完整性，不会因为并发导致数据...
多线程-狂神说Java学习笔记
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
Java多线程自学笔记
01-19
### Java多线程自学笔记知识点总结 #### 一、Java多线程概念 - **多线程定义**：多线程是指程序中可以同时执行多个线程的能力。Java虚拟机支持多线程机制，允许应用程序在不同的线程上并行执行任务。 - **线程特点...
Java多线程源码笔记.pdf
05-08
1. Thread类解析：Thread类是Java多线程的基础，它拥有start()方法来启动线程，run()方法用来执行线程的逻辑。通过重写run()方法，你可以定义线程执行的具体任务。 2. 使用多线程需要注意的问题：多线程环境下，...
关于synchronized同步方法
maimai的博客
05-04 378
修饰同步方法：作用于当前实例加锁，进入同步代码前要获得当前实例的锁。 public class TestThread { public synchronized void car1(){ System.out.println(Thread.currentThread()+"获得资源"); try { Thread.currentThread().sleep(3000); } catch (InterruptedExcepti
Java多线程详解（七）线程同步机制
筱寒小记
06-11 193
线程同步 现实生活中，我们会遇到“同一个资源，多个人都想使用”的问题，比如，食堂排队打饭，每个人都想吃饭，最天然的解决办法就是排队，一个个来。 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这是我们就需要用到线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕，下一个线程再使用。 形成条件 队列+锁 由于统一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中
同步方法（Synchronized Methods）
平凡
07-05 3383
java编程语言提供两种基本的同步方式：同步方法和同步代码块，其中比较复杂的同步代码块会在下一节当中讨论，这一节主要是讲解同步方法。   为了实现方法同步，只要简单的将关键字synchronized添加到方法的声明处，如：public class SynchronizedCounter{ private int c = 0; public synchronized void incre
2、 synchronized同步方法
天下没有难写的代码
11-30 290
对象及变量的并发访问 1 synchronized同步方法 1.3 方法内部的变量都是不存在线程安全问题，永远都是线程安全的，因为方法内部的变量是私有的特性造成的。 1.4 实例变量就会存在线程安全问题 package thread; public class HaselfPrivateNum { private int num = 0 ; public void addI(String ...
synchronized同步方法的使用
Satisfy_555的博客
07-10 315
一、synchronized同步方法：1.方法内的变量为线程安全public class HasSelfPrivateNum { public void addI(String userName){ try{ int num = 0; if(userName.equals("a")){ num = 100; System.out.println("a set o...
Synchronized 同步方法和同步代码块
chzhh383
06-02 166
public class Foo implements Runnable{ private static byte[] lock = new byte[0]; @Override public void run() { methodA(); } public synchronized void methodA(){ ...
【Java学习笔记（七十七）】之 synchronized同步方法，同步代码块
开发小鸽
12-16 1293
本文章由公号【开发小鸽】发布！欢迎关注！！！ 老规矩–妹妹镇楼： 一． synchronized同步方法 （一） 非线程安全        非线程安全问题会在多个线程对同一个对象中的实例变量进行并发访问时发生，结果就是获取到已经被修改过的数据，即“脏读”。 （二） 方法内的变量是线程安全的        非线程安全问题针对的是实例变量被并发访问的情况，而存在于方法内部的私有变量是不会被其他方法访问到的，因此不
Java多线程编程详解：线程创建与同步
"这篇文档是关于多线程学习的笔记，涵盖了线程与进程的区别、线程的三种创建方式以及线程同步和生产者消费者模式等核心概念。" 在计算机科学中，进程和线程是操作系统中的两个基本概念。一个进程可以被视为一个独立...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值