volatile
只能保证内存可见性(线程A对volatile变量的操作,线程B可见),但无法保证复合操作的原子性(线程A和线程B同时对volatile变量做操作,无法保证原子性)
synchronized
主要有4种加锁方式:
1. 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象;
2. 修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
3. 修饰一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象;因为Class数据存在于永久代,因此静态方法锁相当于该类的一个全局锁;
4. 修饰一个类,其作用的范围是synchronized后面括号括起来的部分,作用主的对象是这个类的所有对象。
1-1. 多个线程访问 同一对象 的同步代码块
/*
线程对象,需要同步的对象为Count
*/
public class ThreadSyn implements Runnable {
private volatile static Integer Count = 0;
@Override
public void run() {
synchronized (this.Count) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + ": " + (Count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
/*
场景类
其中线程thread1和thread2访问的其实是相同的对象(threadSyn)
synchronized锁定的是被其修饰的对象,所以两个线程会产生互斥
只有当一个同步代码块执行结束后,锁释放了,其他线程才有"机会"竞争到该锁
*/
public class TestSynchronized {
public static void main(String[] args) {
ThreadSyn threadSyn = new ThreadSyn();
Thread thread1 = new Thread(threadSyn, "ThreadSynOne");
Thread thread2 = new Thread(threadSyn, "ThreadSynTwo");
thread1.start();
thread2.start();
}
}
1-2. 多个线程访问 不同对象 的同步代码块
/*
修改后的场景类
其中线程thread1和thread2访问的其实是两个不同的对象(threadSyn,threadSyn2)
synchronized锁定的是不同的对象,所以两个线程不会产生互斥
*/
public class TestSynchronized {
public static void main(String[] args) {
ThreadSyn threadSyn = new ThreadSyn();
ThreadSyn threadSyn2 = new ThreadSyn();
Thread thread1 = new Thread(threadSyn, "ThreadSynOne");
Thread thread2 = new Thread(threadSyn2, "ThreadSynTwo");
thread1.start();
thread2.start();
}
}
1-3. 多个线程访问synchronized和非synchronized代码块
一个线程访问对象 的同步代码块,另一个线程可以访问该对象的非同步代码;两者不互斥。
/*
根据线程名称来区分,进入synchronized同步代码块,或进入非synchronized代码块
*/
public class ThreadSyn implements Runnable {
private volatile static Integer Count = 0;
@Override
public void run() {
String threadName = Thread.currentThread().getName();
if (threadName.equals("ThreadSynOne")) {
synchronized (this.Count) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + " count :" + (Count++));
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} else if (threadName.equals("ThreadSynTwo")) {
for (int j = 0; j < 5; j++) {
try {
System.out.println(Thread.currentThread().getName() + " j :" + j);
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
小技巧:
如果只是想通过synchronized来同步代码块,而不是像synchronized(obj)之类的给obj对象加锁,则可以使用如下的方法来构建轻量的锁对象。
零长度的byte数组对象创建起来将比任何对象都经济,查看编译后的字节码:生成零长度的byte[]对象只需3条操作码,而Object lock = new Object()则需要7行操作码。
class Test implements Runnable {
private final byte[] LOCK= new byte[0]; // 特殊的instance变量,堆上创建,对象的引用地址不可变
public void method() {
synchronized (this.LOCK) {
// todo 同步代码块
}
}
public void run() {
}
}
2 synchronized修饰一个方法
synchronized修饰方法和修饰一个代码块类似,只是作用范围不一样,修饰代码块是大括号括起来的范围,而修饰方法范围是整个函数。如将上面demo中的run()方法改成如下的方式,实现的效果一样。
注意点:
1. synchronized关键字不能继承。
虽然可以使用synchronized来定义方法,但synchronized并不属于方法定义的一部分,因此,synchronized关键字不能被继承。
如果在父类中的某个方法使用了synchronized关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized关键字才可以。
还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了。
/*
场景一:子类显式得增加synchronized关键字
*/
class Parent {
public synchronized void method() {
//todo
}
}
class Child extends Parent {
@Override
public synchronized void method() {
//todo
}
}
/*
场景二:子类调用父类的同步方法
*/
class Parent {
public synchronized void ParentMethod() {
//todo
}
}
class Child extends Parent {
public void childMethod() {
super.ParentMethod();
}
}
2、 在定义接口方法时不能使用synchronized关键字。
构造方法不能使用synchronized关键字,但可以使用synchronized代码块来进行同步。
3、Synchronized修饰方法的缺陷
同步方法,这时synchronized锁定的是哪个对象呢?它锁定的是调用这个同步方法对象。
也就是说,当一个对象 P1在不同的线程中执行这个同步方法时,它们之间会形成互斥,达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加 了synchronized关键字的方法。
同步方法实质是将synchronized作用于object reference(对象的引用,即对象在堆上创建的地址)。
线程拿到了P1对象锁,才可以调用P1的同步方法,而对P2而言,P1这个锁与它毫不相干,程序也可能在这种情形下摆脱同步机制的控制,造成数据混乱。
若将一个大的方法声明为synchronized 将会大大影响效率,典型地,若将线程类的方法 run() 声明为 synchronized ,由于在线程的整个生命期内它一直在运行,因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中,将其声明为 synchronized ,并在主方法中调用来解决这一问题,但是 Java 为我们提供了更好的解决办法,那就是 synchronized代码块(上面已经说了)
3 synchronized修饰静态方法
静态方法是属于类的而不属于对象的。同样的,synchronized修饰的静态方法锁定的是这个类的所有对象。
/*
threadSynOne和threadSynTwo是SyncThread的两个对象,但在thread1和thread2并发执行时却保持了线程同步。
这是因为run中调用了静态方法method,而静态方法是属于类的,所以threadSynOne和threadSynTwo相当于用了同一把锁。
*/
public class ThreadSyn implements Runnable {
private volatile static int count = 0;
@Override
public void run() {
method();
}
public synchronized static void method() {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + " count :" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
4.synchronized作用于一个类
synchronized作用于一个类时,是给这个类加锁,这个类的所有对象用的是同一把锁
/*
给类加锁
*/
public class ThreadSyn implements Runnable {
private volatile static int count = 0;
@Override
public void run() {
method();
}
public static void method() {
synchronized (ThreadSyn.class) {
for (int i = 0; i < 5; i++) {
try {
System.out.println(Thread.currentThread().getName() + " count :" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
举例:Synchronized同步方法和同步代码块
1、因为同步方法锁的是方法的this
,也就是执行这个方法的对象。
因为是起了两个对象(classLocker1 和classLocker2)作为两个线程,所以不存在竞争行为。
public class TestSynchronized {
public static void main(String[] args) {
TestSynchronized classLocker1 = new TestSynchronized();
TestSynchronized classLocker2 = new TestSynchronized();
new Thread(() -> classLocker1.lock()).start();
new Thread(() -> classLocker2.lock()).start();
}
//修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
//对象classLocker1和classLocker2为不同对象,不产生冲突
private synchronized void lock() {
int i = 0;
do {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this + " is locked " + i);
} while (i++ < 10);
}
}
2、修改:两个线程改为都是执行对象1的lock
方法,此时的结果必然为线程对象classLocker1,依次打印0—10,再打印0—10
public class TestSynchronized {
public static void main(String[] args) {
TestSynchronized classLocker1 = new TestSynchronized();
TestSynchronized classLocker2 = new TestSynchronized();
new Thread(() -> classLocker1.lock()).start();
new Thread(() -> classLocker1.lock()).start();
}
//修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
//对象classLocker1和classLocker2为不同对象,不产生冲突
private synchronized void lock() {
int i = 0;
do {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this + " is locked " + i);
} while (i++ < 10);
}
}
3、若为同步代码块,同步代码块是显式声明资源。
public class TestSynchronized {
public static void main(String[] args) {
TestSynchronized classLocker1 = new TestSynchronized();
TestSynchronized classLocker2 = new TestSynchronized();
new Thread(() -> classLocker1.lock()).start();
new Thread(() -> classLocker2.lock()).start();
}
//修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
//对象classLocker1和classLocker2为不同对象,不产生冲突
private void lock() {
//synchronized (this)
synchronized (this.getClass()) {
int i = 0;
do {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this + " is locked " + i);
} while (i++ < 10);
}
}
}
- 当括号里是
this
时,锁的是当前调用方法的对象(依次为classLocker1和classLocker2)————运行结果必然是:classLocker1线程对象和classLocker2线程对象并行地打印0—10,因为是两个不同的对象占用的锁,互不影响;(对象锁) - 当括号里是一个
Class
对象时,锁的是这个类,也就是同一个类的实例,任意时刻只会有一个线程能获得资源。——运行结果必然是:classLocker1线程对象打印0—10,然后classLocker2线程对象打印0—10;(类锁)