1 join
join: 合并线程,多个线程合并为一个线程
public static void main(String[] args) {
Thread t1=new Thread(new Processer_01());
Thread t2=new Thread(new Processer_01());
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
try {
//执行到join的时候,因为是t1调用的,所以main之后的代码必须等t1执行完之后才能执行
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
class Processer_01 implements Runnable{
@Override
public void run() {
for (int i = 0; i <5; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
2 yield
yield: 暂停当前正在执行的线程,并让其他线程执行
* 1 是静态方法,写在哪个线程中哪个线程就让位
* 2 只能给同优先级的线程让位,不同优先级的不能让位
* 3 只让出当前执行的时间片,下次就不让了,要让就重新调用
* yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会
* 因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行
* 但是,实际中无法保证yield()达到让步的目的,因为让步的线程还有可能被线程调度程序再次选中
* 结论: yield()从未导致线程转到等待/睡眠/阻塞状态
* 在大多数情况下,yield()将导致线程从运行状态转到可运行状态,但有可能没有效果
代码:public static void main(String[] args) {
Thread t1=new Processer_02();
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+" : "+i);
}
}
}
class Processer_02 extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i%2==0) {
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" : "+i);
}
}
3 线程同步
问题的提出
多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据
线程同步:
* 当多个线程同时操作同一个数据的时候,尤其是做更改操作,为了保证数据的一致性和正确性,需要进行一定的保护
* 所以线程同步是一种数据安全机制
*
* 同步编译和异步编译:
* 同步编程: 线程之间不是独立的,相互之间有影响,必须一个一个执行
* 异步编程: 线程之间是独立的,相互之间没有影响
*
* 以下程序因为同时操作了某个数据导致了结果不正确
* 1 可以使用synchronized修饰符解决
* 使用方式 public synchronized void m1(){}
* 使用synchronized修饰的方法,不能被多个线程同时执行
* 比如: 访问该对象中的某一个加锁的成员方法,那么该对象中的所有加锁的成员方法都被锁定,
* 其他线程都无法访问,只能排队等待该线程执行结束交出锁后再访问
* 2 synchronized(){}语句块解决
* synchronized(对象){
* //这种方式是把该对象中所有加锁的成员方法和代码块锁全部锁定
* 同步代码;
* }
* synchronized(类名.class){
* //这种方法是把该类中所有加锁的静态方法和代码块锁全部锁定
* 同步代码;
* }
public static void main(String[] args) {
A a = new A(10);
A a1 = new A(11);
Thread t1 = new Thread(new Processor_03(a));
Thread t2 = new Thread(new Processor_03(a));
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
class Processor_03 implements Runnable {
A a;
public Processor_03(A a) {
super();
this.a = a;
}
@Override
public void run() {
a.m1();
}
}
class A {
int i;
// 方法锁
// public synchronized void m1() {
public void m1() {
System.out.println("-----------");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 代码块锁
synchronized(this){
i++;
System.out.println(Thread.currentThread().getName() + " : " + i);
}
System.out.println("==========");
}
public A(int i) {
super();
this.i = i;
}
}
- 多线程出现了安全问题
- 问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误。
- 解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行。
Synchronized的使用方法
- Java对于多线程的安全问题提供了专业的解决方式：同步机制
- 同步代码块：
synchronized (对象){
// 需要被同步的代码；
}
- synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如：
public synchronized void show (String name){
….
}
4 同步机制中的锁
同步锁机制：
在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防 止两个任务访问相同的资源（其实就是共享资源竞争）。 防止这种冲突的方法 就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须 锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁 之时，另一个任务就可以锁定并使用它了。
- synchronized的锁是什么？
- 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
- 同步方法的锁：静态方法（类名.class）、非静态方法（this）
- 同步代码块：自己指定，很多时候也是指定为this或类名.class
- 注意：
- 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就
无法保证共享资源的安全
- 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方 法共用同一把锁（this），同步代码块（指定需谨慎）
释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、 该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导
致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线 程暂停，并释放锁。
不会释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、
Thread.yield()方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程
挂起，该线程不会释放锁（同步监视器）。
-
- 应尽量避免使用suspend()和resume()来控制线程
5 Lock锁
JDK5.0提出: 代码块锁,性能较好 又称为显式锁,因为开启和关闭都是手动的 synchronized是隐式锁,因为执行完会自动解锁
public static void main(String[] args) {
A1 a = new A1(10);
Thread t1 = new Thread(new Processor_04(a));
Thread t2 = new Thread(new Processor_04(a));
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
}
}
class Processor_04 implements Runnable {
A1 a;
public Processor_04(A1 a) {
super();
this.a = a;
}
@Override
public void run() {
a.m1();
}
}
class A1 {
int i;
// 创建锁对象
Lock lock = new ReentrantLock();
public void m1() {
System.out.println("-----------");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// synchronized (this) {
// 开始加锁
lock.lock();
i++;
System.out.println(Thread.currentThread().getName() + " : " + i);
// 解锁
lock.unlock();
// }
System.out.println("==========");
}
public A1(int i) {
super();
this.i = i;
}
}
synchronized 与 Lock 的对比
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是 隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有
更好的扩展性（提供更多的子类）
优先使用顺序：
Lock 同步代码块（已经进入了方法体，分配了相应资源） à 同步方法
（在方法体之外）
6 定时器
public static void main(String[] args)throws ParseException {
//创建定时器
Timer timer=new Timer();
//三个参数分别是
//1 做什么事
//2 开始时间,可以是时间(待了指定时间开始执行),也可以是毫秒数(当前时间开始,多长时间之后开始执行)
//3 执行的时间间隔
//两秒之后开始执行,并且每隔一秒执行一次
//timer.schedule(new LogTimerTask(), 2000,1000);
long m=System.currentTimeMillis();
m += 1000 * 60;
String string = "2021-10-29 10:50:00 000";
Date d = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").parse(string);
timer.schedule(new LogTimerTask(), d, 1000);
System.out.println("----------");
}
}
//任务类
class LogTimerTask extends TimerTask{
@Override
public void run() {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS")
.format(new Date()));
}
}
7 死锁
死锁问题:
* 在执行过程中,所有线程都遇到了加锁的功能,从而进入等待状态,导致大家都访问不了
* 1 某个线程执行完成,需要先后嵌套锁定两个对象
* 2 A线程先进入第一个对象并锁定了第一个对象,并且在第一个对象中去嵌套访问并锁定第二个对象
* 3 同时,B线程进入并锁定了第二个对象,还嵌套访问了并锁定了第一个对象
* 4 当A线程把第一个对象锁定后,要去访问第二个对象的时候,发现已经被B线程锁住了,只能等待B线程交出第二个对象的锁才能执行
* 5 线程B与线程A同理,无法执行
代码:
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new T1(o1, o2);
Thread t2 = new Thread(new T2(o1, o2));
t1.start();
t2.start();
}
}
class T1 extends Thread {
Object o1;
Object o2;
public T1(Object o1, Object o2) {
super();
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o1) {
//打印需要调用方法,耗时较长,所以大概率出现死锁
System.out.println("t1已进入o1 准备进入后o2");
synchronized (o2) {
System.out.println("t1 执行完成");
}
}
}
}
class T2 extends Thread {
Object o1;
Object o2;
public T2(Object o1, Object o2) {
super();
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o2) {
System.out.println("t2已进入o2 准备进入后o1");
synchronized (o1) {
System.out.println("t2 执行完成");
}
}
}
}
8 线程通信
8.1 概述
8.3 使用方式
wait: 让当前线程进入等待状态,无参或传入0都意味着不可以自动醒,只能被唤醒,也可以传入毫秒数到时间会自动醒
* notify: 唤醒当前对象中等待的某一个线程
* notifyAll: 唤醒当前对象中等待的所有线程
*
* 以上两种方法必须用在成员加锁的方法中
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();
t1.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.printOdd();
}
}
}
// 业务类
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();
}
}
}
