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();
}
233
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
