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=2013:重入锁
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：死锁
死锁的产生条件：当获取锁后，服务器宕机，持有锁，但其他服务器无法获得锁
跟互相引用差不多吧。
本文参与 腾讯云自媒体分享计划，分享自微信公众号。
原始发表：2020-02-23，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读