2020.6.6课堂笔记
多线程
线程安全
几个窗口同时卖票,卖票时出现一些不合理的票数据。
- 出现0票或负票原因:由于线程的随机性
- 出现相同票:线程的原子性所导致(内存模型会讲解)例如[ piao- -就是多个语句,不是原子性操作]。
- 出现线程安全的问题的要符合三个条件(不满足这几个条件的不会出现线程安全)
- 多线程环境
- 多个线程共享数据
- 多条语句操作共享变量(实际代码中,我们可以改变的位置,来保证线程安全)
- 解决方式:把有可能出现数据安全的代码,使用同步代码块包裹
- 同步代码块语法:synchronized (对象–>这里的对象就是锁){可能出现线程安全的代码}
- 锁(监视器):可以使用Java中任意一个对象充当锁(内置锁)。这个锁是互斥锁,不释放锁,其他线程不能持有。
- 一定要让多个线程共享一把锁,才能锁住。
- 锁住的原因:当一个线程th1进入同步代码块,就持有这个锁,那么其他线程没有锁,就只能等待在外面。th1执行完了,出了同步代码块,就会释放锁,然后所有线程再次争抢时间片。抢到再锁住重复上面步骤。
- 同步的好坏:保证线程的安全性,但是会降低效率。
原子性操作
- 什么是原子性操作,就是一个或者多个操作,只能在一个线程完成之后,另一个线程才能开始操作。也就是说这个操作不可分割。
- 例如:i ++就不是原子操作,
- 读取变量值
- 将变量值+1
- 将结果写入变量中
- 不是原子操作就是因为,在这三个步骤中,多个线程可以自由切换,不是强制这三个步骤执行完才切换。如果这样就会使 i值没有被更新就被多个线程读取到,最终出现相同票,或者负票。
同步方法
-
把一个方法用synchronized修饰
-
同步方法默认用的锁对象是;this
-
静态同步方法:默认用的锁对象是< 当前类.class >当前类的字节码对象。
-
同步代码块的优缺点:
- 优点是:保证了多线程的安全,
- 缺点:由于每个线程都会判断同步上的锁,因此提高了资源耗费,降低了运行效率
代码
1.package org.westos.demo8;
/*Author:LH
CreatTime:2020.06.10.15:51*/
//买票的线程安全 使用同步代码块
public class Test {
public static void main(String[] args) {
new MyThread("窗口1").start();
new MyThread("窗口2").start();
new MyThread("窗口3").start();
}
}
class MyThread extends Thread {
private static int trick = 100;
static Object obj = new Object();
public MyThread(String name) {
super(name);
}
@Override
public void run() {
//
while (true) {
// 使用synchronized 同步代码块,可以是多线程安全。此处要注意,多个线程的锁,也就是obj对象必须唯一,不能每一个对象持有一把锁,那就失去互锁的意义。
synchronized (obj) {
// 票的循环结束控制语句必须包含在synchronized的大括号里面,否则还会出现安全问题
if (trick >= 1) {
try {
Thread.sleep(50);
System.out.println(Thread.currentThread().getName() + "卖出第:" + (trick) + " 张票");
trick--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
2.
package org.westos.demo8;
/*Author:LH
CreatTime:2020.06.10.21:42*/
public class Test2 {
public static void main(String[] args) {
MyRunable runable = new MyRunable();
Thread th1 = new Thread(runable);
th1.setName("窗口1");
Thread th2 = new Thread(runable);
th2.setName("窗口2");
Thread th3 = new Thread(runable);
th3.setName("窗口3");
th1.start();
th2.start();
th3.start();
}
}
class MyRunable implements Runnable {
private static int trick = 100;
@Override
public void run() {
int i = 1;
while (true) {
if (i % 2 == 0) {
// 由于要保持线程锁对象一致,因为同步方法的锁对象是this
// 所以此处的同步代码块的对象也要是this
synchronized (this) {
if (trick >= 1) {
try {
Thread.sleep(50);
System.out.println(Thread.currentThread().getName() + "卖出第:" + (trick) + " 张票");
trick--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} else {
sellTrick();
}
i++;
}
}
private synchronized void sellTrick() {
if (trick >= 1) {
try {
Thread.sleep(50);
System.out.println(Thread.currentThread().getName() + "卖出第:" + (trick) + " 张票");
trick--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
3.
package org.westos.demo8;
/*Author:LH
CreatTime:2020.06.10.21:42*/
public class Test3 {
public static void main(String[] args) {
MyRunable2 runable2 = new MyRunable2();
Thread th1 = new Thread(runable2);
th1.setName("窗口1");
Thread th2 = new Thread(runable2);
th2.setName("窗口2");
Thread th3 = new Thread(runable2);
th3.setName("窗口3");
th1.start();
th2.start();
th3.start();
}
}
class MyRunable2 implements Runnable {
private static int trick = 100;
@Override
public void run() {
int i = 1;
while (true) {
if (i % 2 == 0) {
// 由于要保持线程锁对象一致,因为静态同步方法的锁对象是当前类的class文件,
// 所以此处的同步代码块的对象也要是(MyRunable2.class
synchronized (MyRunable2.class) {
if (trick >= 1) {
try {
Thread.sleep(50);
System.out.println(Thread.currentThread().getName() + "卖出第:" + (trick) + " 张票");
trick--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} else {
sellTrick();
}
i++;
}
}
static synchronized void sellTrick() {
if (trick >= 1) {
try {
Thread.sleep(50);
System.out.println(Thread.currentThread().getName() + "卖出第:" + (trick) + " 张票");
trick--;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
使用Lock接口的实现类来加锁和释放锁。确保锁一定被释放。
- Lock实现类提供比使用synchronized方法和语句可以获得的更广泛的锁定操作。 它们允许更灵活的结构化,可能具有完全不同的属性,并且可以支持多个关联的Condition对象。
- ReentrantLock 可重入互斥Lock
具有与使用
synchronized方法和语句访问的隐式监视锁相同的基本行为和语义,但具有扩展功能。- 常用方法:lock:获得锁
- unlock:释放此锁
- 规范的写法
package org.westos.demo9;
import java.util.concurrent.locks.ReentrantLock;
/*Author:LH
CreatTime:2020.06.10.22:39*/
//lock 接口的实现类
public class Test {
public static void main(String[] args) {
new MyThread().start();
new MyThread().start();
new MyThread().start();
}
}
class MyThread extends Thread {
static int trick = 100;
static ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
// 加锁。也就是这个线程的得到锁,其他线程就不能进来
lock.lock();
try {
if (trick >= 1) {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + "出售第" + (trick--) + "张票");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
- 创建一个LOCK的子类对象,并调用其方法,可以把线程不安全的类转换成线程安全的
死锁
- 就是synchronized语句的嵌套。
- 通缩的就是,线程1持有线程2 往下运行所需的锁,线程2也持有线程1往下运行的锁,这样两个线程都不能运行完成,释放锁。又都需要对方手里的锁,所以就会陷入僵局。变成死锁。
案例
package org.westos.demo11;
/*Author:LH
CreatTime:2020.06.11.14:31*/
//测试死锁程序
//死锁代码块的特点是,互斥锁的相互获得后的限制
public class Test {
public static void main(String[] args) {
new MyThread(true).start();
new MyThread(false).start();
}
}
//创建线程
class MyThread extends Thread implements Myuntils {
private boolean flag;
public MyThread(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
if (flag){
// 根据标记两个线程进来,获得各自的锁,并进入代码
synchronized (o1){
System.out.println("true执行了");
// TH1线程执行到这里时,需要o2这把锁,但是o2这把锁被TH2线程持有,并且没有被释放,所以只能等待
synchronized (o2){
System.out.println("true执行第二步");
}
}
}else {
synchronized (o2){
System.out.println("false执行了");
// TH2线程执行到这里时,需要o1这把锁,但是o1这把锁被TH1线程持有,并且没有被释放,所以只能等待
// 这样两个线程就被相互限制,进入死锁状态,无限的等待
synchronized (o1){
System.out.println("false执行第二步");
}
}
}
}
}
//工具是为了给提供两个锁
interface Myuntils {
Object o1 = new Object();
Object o2 = new Object();
}