java synchronized 还是用redis 锁 java的synchronized的实现原理

synchronized是同步的意思，在java多线程中，我们一般会考虑共享数据的处理，共享数据的处理包含两块，第一是共享数据，第二是在多线程访问共享数据的时候，如果处理共享数据，保证数据的有效正确性。

我们要保证线程A访问共享数据，对数据进行处理的时候，其他线程能够等待线程A访问完毕后，和线程A看到相同的数据，再进行自己的业务处理，这也就是互斥锁。

java中，synchronized可以保证同一时刻，只有一个线程对某个方法某个代码块访问的时候。synchronized还有一个作用，保证一个线程的变化(主要是共享数据的变化)，能够被其他线程看到。

synchronized的三种应用方式：

1、修饰实例方法，作用于实例方法，给实例加锁

2、修饰静态方法，给当前类加锁，要访问代码前，要获得类对象的锁

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

修饰实例方法

同步锁是给对象的，下面代码中，一个对象只有一把同步锁，两个线程获取同一把锁，所以thread2只能等到thread完成业务逻辑，释放同步锁，thread2才能获得锁，进行操作。运行结束后i的值为2000000。

package sychronized;
public class SychronizedTest implements Runnable {
     
     static int i = 0;
     
     public static void main(String[] args) throws InterruptedException {        SychronizedTest test = new SychronizedTest();
         
         Thread thread = new Thread(test);
         Thread thread2 = new Thread(test);
         
         thread.start();
         thread2.start();
         
         thread.join();
         thread2.join();
         
         System.out.print(i);
     }    @Override
     public void run() {
         for(int j=0;j<1000000;j++){
             increase();
         }
     }
     
     //对方法加了互斥锁
     public synchronized void increase(){
         i++;
     }
 }

如果此时thread和thread2获得的锁是不一样的对象，那么这两个线程是互补干扰的，不用相互等待对方获得互斥锁，各自可以获得对象锁，进行操作。这种情况下i的值就会被这两个线程同时操作，那么运行的结果就肯定是小于2000000。因为两个线程同时操作，异步进行。

修饰静态方法

当synchronized作用于静态方法，那么锁就是当前class对象锁。由于静态成员不属于任何一个实例对象，而是属于类成员，因此通过class对象锁来控制静态成功的并发控制。如果一个线程调用一个实例对象的非static synchronized方法，并不会影响另外的线程调用该实例对象的synchronized方法，不会出现互斥现象。访问静态同步方法占用的锁是当前类的class对象，而访问非静态同步方法占用的锁是实例对象锁。

package sychronized;
public class SychronizedTest implements Runnable {
     
     static int i = 0;
     
     public static void main(String[] args) throws InterruptedException {        SychronizedTest test = new SychronizedTest();
         SychronizedTest test1 = new SychronizedTest();
         
         Thread thread = new Thread(test);
         Thread thread2 = new Thread(test1);
         
         thread.start();
         thread2.start();
         
         thread.join();
         thread2.join();
         
         System.out.print(i);
     }    @Override
     public void run() {
         for(int j=0;j<1000000;j++){
             //如果run是调用increase方法，此方法是静态方法，锁是当前的类对象锁，不属于任何一个实例化对象，结果是2000000
             increase();
             //如果run是调用increase1方法，那这个方法是实例化对象锁，多线程占用同一个对象锁，需要等待，多线程
             //占用不一样的锁，是互斥锁，不需要等待其他线程释放，就可以占用锁，结果小于2000000
             increase1();
         }
     }
     
     //对方法加了互斥锁
     public static synchronized void increase(){
         i++;
     }
     
     public synchronized void increase1(){
         i++;
     }
 }

猜你喜欢