Day_24_线程（下）

最新推荐文章于 2024-09-15 19:46:31 发布

势不可挡の内鬼

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量127

点赞数

分类专栏：学习日志文章标签： java

本文链接：https://blog.csdn.net/m0_51589970/article/details/121041525

版权

学习日志专栏收录该内容

52 篇文章 0 订阅

订阅专栏

8.2 join

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

public class Thread_01_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);
		}
	}
}

8.3 yield

yield : 暂停当前正在执行的线程,并让其他线程执行
        1 静态方法,写在哪个线程中,哪个线程让位
        2 给同优先级让位,不同优先级不让位
        3 只让出当前执行的时间片,下次让不让另说

        yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。
        因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。
        但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

   结论：yield()从未导致线程转到等待/睡眠/阻塞状态。
   在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果

public class Thread_02_Yield {
	public static void main(String[] args) {
		Thread t1 = new Processor_02();
		t1.start();
		
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+" : "+i);
		}
	}
}
class Processor_02 extends Thread{
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			if (i % 2 == 0) {
				Thread.yield();
			}
			System.out.println(getName()+" : "+i);
		}
	}
}

9. 线程的同步

线程同步 :

        当多个线程同时操作同一个数据的时候,尤其是更改操作,为了保证数据的一致性和正确性,需要进行一定的保护，所以线程同步是一种数据安全机制

同步编译和异步编程
        同步编程 : 线程之间不是独立的,相互有影响,必须一个个执行
        异步编程 : 线程之间是独立的,相互没有影响
        以下程序因为同时操作了某个数据,导致结果不正确
                1.可以使用 synchronized 修饰符解决
                使用方式 public synchronized void m1(){} 使用synchronized的方法,不能被多个线程同时执行
                比如访问该对象中的某一个加锁的成员方法,那么该对象中所有的加锁的成员方法全部锁定,
                其他线程都无法访问,只能排到等待,等待该线程执行结束,交出锁
                比如访问一个类的加锁的静态方法,那么该类中所有加锁的静态方法全部锁定
                2.synchronized(){} 语句块解决
                synchronized(对象){ // 这种方式是把该对象中所有加锁的成员方法和代码块锁全部锁定
   同步代码;
   }
   synchronized(类名.class){ // 把该类中所有加锁的静态方法和代码块锁全部锁定
   同步代码;

public class Thread_03_Synchronization {
	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;
	}
}

10. 同步机制中的锁

同步机制锁

在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。

synchronized的锁是什么？

任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
同步方法的锁：静态方法（类名.class）、非静态方法（this）
同步代码块：自己指定，很多时候也是指定为this或类名.class

注意：

必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就

无法保证共享资源的安全

一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）

释放锁的操作

当前线程的同步方法、同步代码块执行结束。
当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导

致异常结束。

当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

不会释放锁的操作

1.线程执行同步代码块或同步方法时，程序调用Thread.sleep()、

Thread.yield()方法暂停当前线程的执行

2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程

挂起，该线程不会释放锁（同步监视器）。

应尽量避免使用suspend()和resume()来控制线程

11. Lock锁

JDK5.0提出代码块锁,性能较好又称为显式锁因为开启和关闭都是手动的

synchronized是隐式锁,因为执行完自动解锁

public class Thread_04_Lock {
	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;
	}
}

11. 定时器

package day_02;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Thread_05_Timer {
	public static void main(String[] args) throws ParseException {
		// 创建定时器
		Timer timer = new Timer();
		// 1 做什么事
		// 2 开始时间 , 可以是时间(到了指定时间开始执行),也可以是毫秒数(当前时间开始,多长时间之后开始执行)
		// 3 执行的间隔时间
		// 两秒之后开始执行,并且每隔1秒执行一次
		// 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()));
	}
}

12. 死锁

死锁 : 在执行过程中,都遇到了加锁的功能,从而进入等待状态,导致大家都访问不了

        1.某个线程执行完成,需要先后嵌套锁定两个对象
        2.A线程先进入第一个对象,并锁定第一个对象,在第一个对象中去嵌套访问并锁定第二个对象
        3.B线程,先进入第二个对象,并锁定第二个对象,在第二个对象中去嵌套访问并锁定第一个对象
        4.当A线程把第一个对象锁定之后,要去访问第二个对象的时候,发现已经被B线程锁住了,只能等待B线程交出第二个对象的锁才能执行
        5.当B线程把第二个对象锁定之后,要去访问第一个对象的时候,发现已经被A线程锁住了,只能等待A线程交出第一个对象的锁才能执行
        6.因此导致 A和B都进入等待状态

public class Thread_06_DeadLock {
	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 执行完成");
				}
			}
	}
}

13. 线程通信

13.1 概述

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