8.2 join
join : 合并线程,多个线程合并为一个线程
8.3 yield
yield : 暂停当前正在执行的线程,并让其他线程执行
1 静态方法,写在哪个线程中,哪个线程让位
2 给同优先级让位,不同优先级不让位
3 只让出当前执行的时间片,下次让不让另说
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。
因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。
但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
结论：yield()从未导致线程转到等待/睡眠/阻塞状态。
在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果
9 线程同步
问题的提出
多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据
线程同步 ;
当多个线程同时操作同一个数据的时候,尤其是更改操作,为了保证数据的一致性和正确性,需要进行一定的保护
所以线程同步是一种数据安全机制
同步编程和异步编程
同步编程 : 线程之间不是独立的,相互有影响,必须一个个执行
异步编程 : 线程之间是独立的,互相没有影响
以下程序 因为同时操作了某个数据,导致结果不正确
1 可以使用 synchronized 修饰符解决
使用方式 public synchronized void m1(){} 使用synchronized的方法,不能被多个线程同时执行
比如 访问该对象中的某一个加锁的成员方法,那么该对象中所有的加锁的成员方法全部锁定,
其他线程都无法访问,只能排到等待,等待该线程执行结束,交出锁
比如访问一个类的加锁的静态方法,那么该类中所有加锁的静态方法 全部锁定
2 synchronized(){} 语句块解决
synchronized(对象){ // 这种方式是把该对象中所有加锁的成员方法和代码块锁全部锁定
同步代码;
}
synchronized(类名.class){ // 把该类中所有加锁的静态方法和代码块锁全部锁定
同步代码;
}
列题：
模拟火车站售票程序，开启三个窗口售票
| class Ticket implements Runnable { private int tick = 100; public void run() { while (true) { if (tick > 0) { System.out.println(Thread.currentThread ().getName() + "售出车票，tick号为：" + tick--); } else{ break; } } } |
| class TicketDemo { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); t1.setName("t1窗口"); t2.setName("t2窗口"); t3.setName("t3窗口"); t1.start(); t2.start(); t3.start(); } } |
理想状态 :
极端状态 :
| private int tick = 100; public void run(){ while(true){ if(tick>0){ try{ Thread.sleep(10); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+“售出车票，tick号为："+tick--); } } } |
- 多线程出现了安全问题
- 问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误。
- 解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行。
同步方法
Synchronized的使用方法
- Java对于多线程的安全问题提供了专业的解决方式：同步机制
- 同步代码块：
synchronized (对象){
// 需要被同步的代码；
}
- synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如：
public synchronized void show (String name){
….
}
10 同步机制中的锁
同步锁机制：
在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防 止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法 就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须 锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁 之时，另一个任务就可以锁定并使用它了。
- synchronized的锁是什么？
- 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
- 同步方法的锁：静态方法（类名.class）、非静态方法（this）
- 同步代码块：自己指定，很多时候也是指定为this或类名.class
- 注意：
- 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就
无法保证共享资源的安全
- 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方 法共用同一把锁（this），同步代码块（指定需谨慎）
释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、 该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导
致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线 程暂停，并释放锁。
不会释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、
Thread.yield()方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程
挂起，该线程不会释放锁（同步监视器）。
-
- 应尽量避免使用suspend()和resume()来控制线程
10、Lock(锁)
- 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同
步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和 内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以 显式加锁、释放锁。
伪代码：
| 3. Lock(锁) class A{ private final ReentrantLock lock = new ReenTrantLock(); public void m(){ lock.lock(); try{ //保证线程安全的代码; } finally{ lock.unlock(); } } } 注意：如果同步代码有异常，要将unlock()写入finally语句块 |
synchronized 与 Lock 的对比
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是 隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有
更好的扩展性（提供更多的子类）
优先使用顺序：
Lock 同步代码块（已经进入了方法体，分配了相应资源） à 同步方法
（在方法体之外）
11 定时锁
12 死锁
死锁 : 在执行过程中,都遇到了加锁的功能,从而进入等待状态,导致大家都访问不了
*
* 1 某个线程执行完成,需要 先后 嵌套 锁定 两个对象
* 2 A线程 先进入第一个对象,并锁定第一个对象,在第一个对象中去嵌套访问并锁定第二个对象
* 3 B线程,先进入第二个对象,并锁定第二个对象,在第二个对象中去嵌套访问并锁定第一个对象
* 4 当A线程把第一个对象锁定之后,要去访问第二个对象的时候,
* 发现已经被B线程锁住了,只能等待B线程交出第二个对象的锁才能执行
* 5 当B线程把第二个对象锁定之后,要去访问第一个对象的时候,
* 发现已经被A线程锁住了,只能等待A线程交出第一个对象的锁才能执行
* 6 因此 导致 A和B都进入等待状态
13 线程通信
生产者/消费者模式的理解及实现_笑看风云路的博客-CSDN博客_生产者消费者模式
13.2 使用方式
wait : 让当前线程进入等待状态 , 无参 或者传入0 都意味着 不可以自动醒,只能被唤醒,也可以传入毫秒数,到时间自动醒
* notifyAll : 唤醒在当前对象中等待的所有线程
* notify : 唤醒在当前对象中等待的摸一个线程
*
* 以上两个方法必须用在成员加锁的方法中
public class Thread_07_Wait {
public static void main(String[] args) {
Num num = new Num();
Thread t1 = new PrintOdd(num);
Thread t2 = new PrintEven(num);
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
class PrintOdd extends Thread {
Num num;
public PrintOdd(Num num) {
super();
this.num = num;
}
@Override
public void run() {
while (true) {
num.printOdd();
}
}
}
class PrintEven extends Thread {
Num num;
public PrintEven(Num num) {
super();
this.num = num;
}
@Override
public void run() {
while (true) {
num.printEven();
}
}
}
// 业务类
class Num {
int count = 1;
public synchronized void printOdd() {
System.out.println(Thread.currentThread().getName() + " : " + count);
count++;
// 唤醒所有在当前对象中睡眠的线程
this.notifyAll();
try {
Thread.sleep(500);
// 挂起 交出该对象持有的锁,让其他线程可以执行
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public synchronized void printEven() {
System.out.println(Thread.currentThread().getName() + " : " + count);
count++;
// 唤醒所有在当前对象中睡眠的线程
this.notifyAll();
try {
Thread.sleep(500);
// 挂起 交出该对象持有的锁,让其他线程可以执行
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
1150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
