Java 学习 day24： 线程join,yield,锁,定时器,死锁,等待挂起wait

1.线程方法

1.1        join

join方法:合并线程,多个线程合并为一个线程

演示代码:

            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);
			}

1.2        yield

yield:暂停当前正在执行的线程,并让其他线程执行

特点:1.静态方法,写在那个线程类中,那个线程让位

        2.给同优先级让位,不同优先级不让位

        3.只让处当前执行的时间片,下次让不让另说

按说,yield应该让位使这个线程转为等待/睡眠/阻塞状态,但是它没有,所以它真的是B用没有,它只是将线程从运行状态转为可运行状态

2.线程同步

2.1        什么情况?

问题的提出:

多个线程执行的不确定性导致执行结果的不稳定

比如:多个线程对账本的共享,会造成操作的不完整性,会破坏数据

 所以就有了线程同步

线程同步:当多个线程同时操作同一个数据时,尤其是更改操作,为了保证数据的正确和统一,需要进行一定的保护机制,这种机制就是线程同步

说白了,线程同步就是个保护多线程下数据安全的机制

同步编程:

线程之间不是独立的,互相有影响,必须一个一个执行

异步编程:

线程之间是独立的,互相没有影响

如何使用线程同步解决问题: 锁

2.2        锁

1.synchronized修饰符:

特点:加在成员方法上,当有一个线程访问该方法时,这时候这个成员的所有上锁的方法全部不能被访问,其他的线程需要访问只能等待,等待使用线程交出锁

2.synchronized语句块

特点:synchronized(对象){同步代码}        这种方式是把对象中的所有加锁的成员方法和加锁语句块全部不能被访问

特点:synchronized(类名.class){同步代码}        这种方式是把类中的所有加锁的静态方法和加锁语句块全部不能被访问

3.lock锁

显式同步锁:

1. java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。
2. ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和 内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以 显式加锁、释放锁。

使用方式:

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;
	}
}

2.3        死锁

什么是死锁:

死锁︰在执行过程中,都遇到了加锁的功能,从而进入等待状态,导致大家都访问不了
1.某个线程执行完成,需要先后嵌套锁定两个对象
2.A线程先进入第一个对象,并锁定第一个对象,在第一个对象中去嵌套访问并锁定第二个对象

3.B线程,先进入第二个对象,并锁定第二个对象,在第二个对象中去嵌套访问并锁定第一个对象

4.当A线程把第一个对象锁定之后,要去访问第二个对象的时候,
发现已经被B线程锁住了,只能等待B线程交出第二个对象的锁才能执行

5.当B线程把第二个对象锁定之后,要去访问第一个对象的时候,
发现已经被A线程锁住了,只能等待A线程交出第一个对象的锁才能执行

6.因此导致A和B都进入等待状态

死锁的演示代码:

public static void main(String[] args) {
			Object o1 = new Object();
			Object o2 = new Object();
			Thread t1 = new T1(o1,o2) ;
			Thread t2 = 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;
	}
	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;
	}
	public void run(){
		synchronized(o2){
			System.out.println("t2已进入o2,准备进入后o1");
			synchronized(o1){
				System.out.println("t2执行完成");
			}
		}

 

3.定时器

public static void main(String[] args) {
		//创建定时器
		Timer timer = new Timer();
		//1.做什么事情
		//2.开始时间,可以是时间(到了指定时间开始执行),也可以是毫秒数(从当前时间开始计算,多长时间后程序执行)
		//3.执行的语句的间隔时间
		//两秒钟之后开始执行,并且每隔一秒执行一次
		//将继承计时器的那个任务类对象传入第一个参数
		timer.schedule(new LogTimerTask(), 2000, 1000);
	}

}
//任务类,就是计时器执行的任务
//必须继承TimerTask类
class LogTimerTask extends TimerTask{
//并覆写里面的run方法,计时器也是个线程
	@Override
	public void run() {
			System.out.println(new SimpleDateFormat("yyyy年MM月dd天 HH点mm分ss秒SSS毫秒").format(new Date()));
	}
	
}

4.线程通信

4.1        概述

都是Object中的方法 

 Notify是随机唤醒一个,无法选择

演示代码:两个线程交替打印奇偶数

public class Thread_07_wait {

	public static void main(String[] args) {
		Num num = new Num();
			Thread t1 = new Thread(new Processer_even(num)) ;
			Thread t2 = new Thread(new Processer_even(num)) ;
			t1.setName("t1");
			t2.setName("t2");
			t1.start();
			t2.start();
	}

}
class Processer_even implements Runnable{
	Num num ;
	
	public Processer_even(Num num) {
		super();
		this.num = num;
	}

	@Override
	public void run() {
			try {
				num.printEven();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
	}
	
}
class Processer_odd implements Runnable{
	Num num ;
	
	public Processer_odd(Num num) {
		super();
		this.num = num;
	}

	@Override
	public void run() {
			try {
				num.printOdd();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
	
}
class Num {
	int i = 1;
	public synchronized void printOdd() throws InterruptedException{
		while(true){
		System.out.println(i);
		i++ ;
		//打印完后唤醒其他线程
		this.notifyAll();
		//自己睡一秒,这时候其他线程应该处于就绪状态
		Thread.sleep(1000);
		//wait方法挂起,锁解除,其他线程可以访问另个一个成员枷锁的方法
		this.wait();
		}
	}
	public synchronized void printEven() throws InterruptedException{
		while(true){
		System.out.println(i);
		i++ ;
		//打印完后唤醒其他线程
		this.notifyAll();
		//自己睡一秒,这时候其他线程应该处于就绪状态
		Thread.sleep(1000);
		//wait方法挂起,锁解除,其他线程可以访问另个一个成员枷锁的方法
		this.wait();
		}
	}
}