java并发编程(二)

继续根据大纲整理问题。

10:对象锁和类锁

synchronized常用于修饰方法和代码块，对象锁作用于对象的实例方法(不能通过类名调用，通过创建对象调用)，比如单例模式的双重检索机制，而类锁并非真的存在。

11:对象锁的同步与异步

同步：即为共享，同步为了解决线程安全问题

异步：即线程间互不影响，相互独立

/**
 * @author zhaokk
 * @create 2020-02-23-14:45
 */
public class SynchronizedDemo {
    private int num=10;

    public synchronized void test(String str) {
        System.out.println(Thread.currentThread().getName());
        try {
            if(str.equals("a")){
                num = 10;
                System.out.println("str a set value");
                Thread.sleep(1000);
            } else {
                num = 20;
                System.out.println("str b set value");
            }
            System.out.println("str="+str+",num="+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void getValue(){
        System.out.println(Thread.currentThread().getName()+"num="+this.num);
    }

    public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo1 = new SynchronizedDemo();
        SynchronizedDemo synchronizedDemo2 = new SynchronizedDemo();
        Thread a = new Thread(() -> {
            synchronizedDemo1.test("a");
        }, "A");

        Thread b = new Thread(() -> {
            synchronizedDemo2.test("b");
        }, "B");
        a.start();
        b.start();
    }
}

此时运行main方法，得到结果

A
str a set value
B
str b set value
str=b,num=20
str=a,num=10

调用两个不同对象的同步方法，synchronized持有的是当前线程的对象锁，彼此之间并无冲突，而当调用同一个对象的同步方法时

 public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        //SynchronizedDemo synchronizedDemo2 = new SynchronizedDemo();
        Thread a = new Thread(() -> {
            synchronizedDemo.test("a");
        }, "A");

        Thread b = new Thread(() -> {
            synchronizedDemo.test("b");
        }, "B");
        a.start();
        b.start();
    }

A
str a set value
str=a,num=10
B
str b set value
str=b,num=20

线程异步执行

12:并发脏读问题

脏读：脏读又称无效数据的读出，是指在数据库访问中，事务T1将某一值修改，然后事务T2读取该值，此后T1因为某种原因撤销对该值的修改，这就导致了T2所读取到的数据是无效的。

 public static void main(String[] args) {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        //SynchronizedDemo synchronizedDemo2 = new SynchronizedDemo();
        Thread a = new Thread(() -> {
            synchronizedDemo.test("a", 20);
        }, "A");

       /* Thread b = new Thread(() -> {
            synchronizedDemo.test("b");
        }, "B");*/
        a.start();
        //b.start();
        synchronizedDemo.getValue();

    }

改变上述方法后，设值为20，但get到的值是10

main方法，num=10
A
test 方法 str=a,num=20

将getValue加上synchronized即可

package com.atkk.thread;

/**
 * @author zhaokk
 * @create 2020-02-23-14:45
 */
public class SynchronizedDemo {
    private int num = 10;

    public synchronized void test(String str, int value) {
        System.out.println(Thread.currentThread().getName());
        num = value;
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("test 方法 str=" + str + ",num=" + num);

    }

    public  synchronized  void getValue() {
        System.out.println(Thread.currentThread().getName() + "方法，num=" + this.num);
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizedDemo synchronizedDemo = new SynchronizedDemo();
        //SynchronizedDemo synchronizedDemo2 = new SynchronizedDemo();
        Thread a = new Thread(() -> {
            synchronizedDemo.test("a", 20);
        }, "A");

       /* Thread b = new Thread(() -> {
            synchronizedDemo.test("b");
        }, "B");*/
        a.start();
        Thread.sleep(1000);
        //b.start();
        synchronizedDemo.getValue();

    }
}

A
test 方法 str=a,num=20
main方法，num=20

13:重入锁

ReentryLock：也叫递归锁，即同一线程外层函数获得锁后，内层函数仍能获取该锁的代码，线程可进入任何一个他已拥有的锁锁同步的代码块。

14:抛异常和锁的关系

当一个线程抛异常时，是否会释放锁

package com.atkk.thread;
/**
 * @author zhaokk
 * @create 2020-02-23-15:49
 */
public class ThreadException {

    public static void main(String[] args) {
        Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
            System.out.printf("线程遇到异常。。。"+thread.getName()+"\n \t", thread.getName(), throwable.getMessage());
        });

        Thread t1 = new Thread(() -> {

                throw new RuntimeException("线程异常....");
        }, "t1");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread t2 = new Thread(() -> {

                throw new RuntimeException("线程异常....");
        }, "t2");
        t1.start();
        System.out.println(t1.getState());
        t2.start();

    }
}

RUNNABLE
线程遇到异常。。。t1
   线程遇到异常。。。t2

在同步代码块中线程是会释放锁的，但此处理解的不够透彻，所以请教

package com.atkk.thread;

/**
 * @author zhaokk
 * @create 2020-02-23-16:36
 */
public class ThreadException2 {

    public static void main(String[] args) {
        Runnable run=()->{
            System.out.println("准备获取锁...."+Thread.currentThread().getName());
            synchronized (ThreadException2.class){
                System.out.println("获取到锁...."+Thread.currentThread().getName());
                throw new RuntimeException();
            }
        };
        Thread t1=new Thread(run),t2=new Thread(run);
        t1.start();
        t2.start();

    }
}

准备获取锁....Thread-0
获取到锁....Thread-0
Exception in thread "Thread-0" java.lang.RuntimeException
  at com.atkk.thread.ThreadException2.lambda$main$0(ThreadException2.java:14)
  at java.lang.Thread.run(Thread.java:748)
准备获取锁....Thread-1
获取到锁....Thread-1
Exception in thread "Thread-1" java.lang.RuntimeException
  at com.atkk.thread.ThreadException2.lambda$main$0(ThreadException2.java:14)
  at java.lang.Thread.run(Thread.java:748)

用Lock会好点。主要作用是如果获取不到锁可以不用等待 可以继续处理其他的事

15：死锁

死锁的产生条件：当获取锁后，服务器宕机，持有锁，但其他服务器无法获得锁

跟互相引用差不多吧。