Java的高并发编程系列(一)synchronized锁

private int count = 10;
public void test(){
    synchronized (this) { //任何线程要执行下面的代码,必须先拿到Demo02对象实例的锁
            count --;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
        }
    }
public synchronized void test(){//等同于synchronized(this),锁定的是Demo03对象的实例
        count --;
        System.out.println(Thread.currentThread().getName() + " count =" + count);
    }

synchronized是对当前对象Object加了一把锁,在当前线程使用过程中其他线程无法调用,只有上一个线程释放锁后,其他线程才可以使用,所以synchronized是互斥锁。在这里需要注意的是,snchronized锁定的是一个对象,而不是一个类或者代码,这个对象是可以自己自定义的,这里是用this锁定了自己。以上两个等同。

public static void test2(){ //考虑一下这里写synchronize(this)是否可以
        synchronized (Demo04.class) {
            count --;
        }
    }

synchronized当锁定静态方法时,那么此时锁定的当前类的class。

public class Demo05 implements Runnable{
    private int count = 10;
    @Override
    public /*synchronized*/ void run(){
        count --;
        System.out.println(Thread.currentThread().getName() + " count = " + count);
    }
    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();
        for (int i = 0; i < 5; i++) {
            new Thread(demo05,"THREAD" + i).start();
        }
    }
}

以上代码Demo05线程,当定义5个线程时,共同调用count,造成的重用,无法进行资源的共享,当添加 synchronized 时,对run方法加了把锁,一次只能一个线程进行调用,不允许其他线程访问,可避免count 的重用,线程的重入。synchronized修饰的代码块是原子操作。

注意:在多线程中,同步方法和非同步方法时可以同时调用的,这两者之间互不影响。

案例:当对业务写方法加锁,而不对读方法加锁时,容易产生脏读问题。

public class Demo08 {
    String name;
    double balance;
    public synchronized void set(String name, double balance){
        this.name = name;
        try {
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.balance = balance;
    }
    public synchronized double getBalance(String name){
        return this.balance;
    }
    pblic static void main(String[] args) {
        Demo08 demo08 = new Demo08();
        new Thread(()->demo08.set("zhangsan",100.0)).start(); //JDK1.8新特性 try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(demo08.getBalance("zhangsan")); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(demo08.getBalance("zhangsan")); } }

在某些业务情况下,当对读取的数据要求不高时,允许脏读的情况下,可以不使用synchronized的情况下,提升性能。

一个同步方法可以调用另一个同步方法,一个线程已经拥有某个对象的锁,再次申请的时候 仍然会得到该对象的锁也就是说synchronized获得的锁是可重入的。

public class Demo09 {
    synchronized void test1(){
        System.out.println("test1 start.........");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        test2();
    }
    synchronized void test2(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test2 start.......");
    }
    public static void main(String[] args) {
        Demo09 demo09 = new Demo09();
        demo09.test1();
    }
}

继承中有可能发生的情形,子类调用父类的同步方法

public class Demo10 {
    synchronized void test(){
        System.out.println("test start........");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test end........");
    }

    public static void main(String[] args) {
        new Demo100().test();
    }
}
class Demo100 extends Demo10{
    @Override
    synchronized void test() {
        System.out.println("child test start.......");
        super.test();
        System.out.println("child test end.......");
    }
}

总而言之:synchronized修饰的锁是可重入的,可以被其他synchronized方法调用。

死锁:简而言之,假如有一个线程需要依次锁定A和B,另一个线程需要依次锁定B和A,此时,第一个线程无法锁定B,第二个线程无法锁定A,这样就产生了死锁。

程序在执行过程中,如果出现异常,默认情况锁会被释放,所以,在并发处理的过程中,有异常要多加小心,不然可能会发生不一致的情况。比如,在一个web app处理过程中,多个servlet线程共同访问通一个资源,这是如果异常处理不合适,在第一个线程中抛出异常,其他线程就会进入同步代码去,有可能访问到异常产生是的数据,因此要非常小心的处理同步业务逻辑中的异常。

public class Demo11 {
    int count = 0;
    synchronized void test(){
        System.out.println(Thread.currentThread().getName() + " start......");
        while (true) {
            count ++;
            System.out.println(Thread.currentThread().getName() + " count = " + count);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                int i = 1/0; //此处抛出异常,锁将被释放,要想不被释放,可以在这里进行catch处理,然后让循环继续
            }
        }
    }
    public static void main(String[] args) {
        Demo11 demo11 = new Demo11();
        Runnable r = new Runnable() {   
            @Override
            public void run() {
                demo11.test();
            }
        };
        new Thread(r, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }   
        new Thread(r, "t2").start();
    }
}
    原文作者:java锁
    原文地址: https://blog.csdn.net/qq_34707744/article/details/79728079
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞