认识达内从这里开始

synchronized关键字最主要有以下3种应用方式，下面分别介绍：

修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁

修饰静态方法，作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁

修饰代码块，指定加锁对象，对给定对象加锁，进入同步代码块前要获得给定对象的锁

1.synchronized作用于实例方法

我们设置类变量static为共享资源， 然后多个线程去修改。修改的含义是：先读取，计算，再写入。那么这个过程就不是原子的，多个线程操作就会出现共享资源争抢问题。

我们在实例方法上添加synchronized，那么，同一个实例执行本方法时，抢到锁到可以执行。

public class AccountingSync implements Runnable{

//共享资源(临界资源)

static int i=0;

/**

* synchronized 修饰实例方法

*/

public synchronized void increase(){

i++;

}

@Override

public void run() {

for(int j=0;j<1000000;j++){

increase();

}

}

public static void main(String[] args) throws InterruptedException {

AccountingSync instance=new AccountingSync();

Thread t1=new Thread(instance);

Thread t2=new Thread(instance);

t1.start();

t2.start();

t1.join();

t2.join();

System.out.println(i);

}

/**

* 输出结果:

* 2000000

*/

}

上述代码中，开启两个线程去操作共享变量，两个线程执行的是同一个实例对象。如果不添加synchronized，其中i++不是原子操作，该操作先读取值，然后再写入一个新值。如果两个线程都读取了i=5，然后线程1写入i=6.线程2后写入，但也是写入i=6, 并不是我们期望的i=7.

添加synchronized修饰后，线程安全，线程必须获取到这个实力到锁才能执行读取和写入。

注意，我们synchronized修饰到是类方法，锁的是实例，当多个线程操作不同实例时，会使用不同实例的锁，就无法保证修改static变量的有序性了。

public class AccountingSyncBad implements Runnable{

static int i=0;

public synchronized void increase(){

i++;

}

@Override

public void run() {

for(int j=0;j<1000000;j++){

increase();

}

}

public static void main(String[] args) throws InterruptedException {

//new新实例

Thread t1=new Thread(new AccountingSyncBad());

//new新实例

Thread t2=new Thread(new AccountingSyncBad());

t1.start();

t2.start();

//join含义:当前线程A等待thread线程终止之后才能从thread.join()返回

t1.join();

t2.join();

System.out.println(i);

}

}

上述代码，两个线程持有不同的对象instance，也就是使用不同的锁， 也就不会互斥访问共享资源，就会出现线程安全问题。

2.synchronized作用于静态方法

synchronized作用于静态方法时，锁就是当前类到class对象锁。由于静态成员变量不专属于任何一个实例对象，是类成员，因此通过class对象锁可以控制静态成员的并发操作。

3.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++操作。当然， 还可以使用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++;

}

}

【免责声明】本文系本网编辑部分转载，转载目的在于传递更多信息，并不代表本网赞同其观点和对其真实性负责。如涉及作品内容、版权和其它问题，请在30日内与管理员联系，我们会予以更改或删除相关文章，以保证您的权益!更多内容请添加danei0707学习了解。欢迎关注“达内在线”参与分销，赚更多好礼。