参考：https://segmentfault.com/a/1190000012203437?utm_source=tag-newest
一、synchronized的三种应用方式
synchronized关键字最主要有以下3种应用方式，下面分别介绍
- 修饰实例方法，作用于当前实例加锁，进入同步代码前要获得 当前实例 的锁
- 修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得 当前类对象 的锁
- 修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码库前要获得 给定对象 的锁
①synchronized作用于实例方法
所谓的实例对象锁就是用synchronized修饰实例对象中的实例方法，注意是实例方法不包括静态方法。
package sychronized;
import static net.mindview.util.Print.*;
import java.util.concurrent.*;
public class AccountingSync2 implements Runnable {
//共享资源(临界资源)
static int i = 0;
//synchronized 修饰实例方法
synchronized void getI() {
if (i % 1000000 == 0) {
print(i);
}
}
public synchronized void increase() {
i++;
getI();
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
print(i);
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
AccountingSync2 accountingSync2 = new AccountingSync2();
exec.execute(accountingSync2);
exec.execute(accountingSync2);
exec.shutdown();
}
}
最后的结果为：
1000000
1519541
2000000
2000000- 上述代码中，我们开启两个线程操作同一个共享资源即变量i，由于i++操作并不具备原子性，该操作是先读取值，然后写回一个新值，相当于原来的值加上1，分两步完成，如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，并执行相同值的加1操作，这也就造成了线程安全失败，因此对于increase方法必须使用synchronized修饰，以便保证线程安全。
- 此时注意到synchronized修饰的是实例方法increase，在这样的情况下，当前线程的锁便是实例对象instance，注意Java中的线程同步锁可以是任意对象。
- 当一个线程正在访问一个对象的 synchronized 实例方法，那么其他线程不能访问该对象的其他 synchronized 方法，毕竟一个对象只有一把锁，当一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，所以无法访问该对象的其他synchronized实例方法，但是其他线程还是可以访问该实例对象的其他非synchronized方法，但是一个 synchronized 方法可以调用另一个需要获得同样锁的synchronized方法，因为已经获取了锁。
- 如果是一个线程 A 需要访问实例对象 obj1 的 synchronized 方法 f1(当前对象锁是obj1)，另一个线程 B 需要访问实例对象 obj2 的 synchronized 方法f2(当前对象锁是obj2)，这样是允许的，因为两个实例对象锁并不同相同，此时如果两个线程操作数据并非共享的，线程安全是有保障的，遗憾的是如果两个线程操作的是共享数据，那么线程安全就有可能无法保证了。
package sychronized;
import static net.mindview.util.Print.*;
import java.util.concurrent.*;
public class AccountingSync2 implements Runnable {
//共享资源(临界资源)
static int i = 0;
//synchronized 修饰实例方法
synchronized void getI() {
if (i % 1000000 == 0) {
print(i);
}
}
public synchronized void increase() {
i++;
getI();
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
print(i);
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
AccountingSync2 accountingSync2 = new AccountingSync2();
exec.execute(accountingSync2);
exec.execute(new AccountingSync2());
exec.shutdown();
}
}
#输出结果：
1000000
1249050
1329218- 上述代码与前面不同的是我们同时创建了两个新实例AccountingSync2，然后启动两个不同的线程对共享变量i进行操作，但很遗憾操作结果是1329218而不是期望结果2000000。
- 虽然我们使用synchronized修饰了increase方法，但却new了两个不同的实例对象，这也就意味着存在着两个不同的实例对象锁，因此两个进程都会进入各自持有对象的对象锁，也就是说两个线程使用的是不同的锁，因此线程安全是无法保证的。
- 解决这种困境的的方式是将synchronized作用于静态的increase方法，这样的话，对象锁就当前类对象，由于无论创建多少个实例对象，但对于的类对象拥有只有一个，所有在这样的情况下对象锁就是唯一的。下面我们看看如何使用将synchronized作用于静态的increase方法。
②synchronized作用于静态方法
当synchronized作用于静态方法时，其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static synchronized 方法，而线程B需要调用这个实例对象所属类的静态 synchronized方法，是允许的，不会发生互斥现象，因为访问静态 synchronized 方法占用的锁是当前类的 class 对象，而访问非静态 synchronized 方法占用的锁是当前实例对象锁。
package sychronized;
import static net.mindview.util.Print.*;
import java.util.concurrent.*;
class OtherTask implements Runnable{
AccountingSyncClass accounting = new AccountingSyncClass();
@Override
public void run(){
for (int j = 0; j < 1000000; j++) {
accounting.increaseForObject();
}
print(accounting.getI());
}
}
public class AccountingSyncClass implements Runnable {
//共享资源(临界资源)
private static int i = 0;
//synchronized 修饰实例方法
public synchronized void increaseForObject() {
i++;
}
public synchronized static void increase() {
i++;
}
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
increase();
}
print(i);
}
public int getI(){
return i;
}
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new AccountingSyncClass());
exec.execute(new AccountingSyncClass());
exec.execute(new OtherTask()); // 1
exec.shutdown();
}
}
输出结果为：
1459696
2692181
2754098
注释掉代码中的 1 那一行代码的输出结果为：
1468495
2000000- 由于synchronized关键字修饰的是静态increase方法，与修饰实例方法不同的是，其锁对象是当前类的class对象。
- 注意代码中的increase4Obj方法是实例方法，其对象锁是当前实例对象，如果别的线程调用该方法，将不会产生互斥现象，毕竟锁对象不同，但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。
- 因此在设计同步代码的时候一定要仔细思考到底该用 多大的同步粒度 和 该对什么对象 使用同步操作。
③synchronized同步代码块
除了使用关键字修饰实例方法和静态方法外，还可以使用同步代码块，在某些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，如果直接对整个方法进行同步操作，可能会得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了。
public class AccountingSync implements Runnable{
static AccountingSync instance=new AccountingSync();
static int i=0;
@Override
public void run() {
//省略其他耗时操作....
//使用同步代码块对变量i进行同步操作,锁对象为instance
synchronized(instance){
for(int j=0;j<1000000;j++){
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(instance);
Thread t2=new Thread(instance);
t1.start();t2.start();
t1.join();t2.join();
System.out.println(i);
}
}- 从代码看出，将synchronized作用于一个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁。
- 如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++操作。
- 当然除了instance作为对象外，我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁。
//this,当前实例对象锁
synchronized(this){
for(int j=0;j<1000000;j++){
i++;
}
}
//class对象锁
synchronized(AccountingSync.class){
for(int j=0;j<1000000;j++){
i++;
}
}二、共同点与区别
- 两者都是可重入锁
两者都是可重入锁。就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁 - Lock是java的一个interface接口，而synchronized是Java中的关键字
synchronized是由JDK实现的，不需要程序员编写代码去控制加锁和释放；Lock的接口如下：
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
Condition newCondition();
}
- synchronized修饰的代码在执行异常时，jdk会自动释放线程占有的锁，不需要程序员去控制释放锁，因此不会导致死锁现象发生；但是，当Lock发生异常时，如果程序没有通过unLock()去释放锁，则很可能造成死锁现象，因此Lock一般都是在finally块中释放锁；格式如下：
Lock lock = new LockImpl; // new 一个Lock的实现类
lock.lock(); // 加锁
try{
//todo
}catch(Exception ex){
// todo
}finally{
lock.unlock(); //释放锁
}
- Lock可以让等待锁的线程响应中断处理，如tryLock(long time, TimeUnit unit)，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够中断，程序员无法控制；
- ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。 ReentrantLock默认情况是非公平的，可以通过 ReentrantLock类的ReentrantLock(boolean fair)构造方法来制定是否是公平的；
扫一扫
861
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
