day24

最新推荐文章于 2022-04-30 15:37:35 发布

路路奈

最新推荐文章于 2022-04-30 15:37:35 发布

阅读量38

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_45312259/article/details/121042970

版权

1.Join

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

2 yield

  yield : 暂停当前正在执行的线程,并让其他线程执行
1 静态方法,写在哪个线程中,哪个线程让位
2 给同优先级让位,不同优先级不让位
3 只让出当前执行的时间片,下次让不让另说
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。
因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。
但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
   结论：yield()从未导致线程转到等待/睡眠/阻塞状态。
   在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果

3线程的同步

多个线程执行的不确定性引起执行结果的不稳定

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

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

synchronized的锁是什么？

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

注意：

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

无法保证共享资源的安全

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

释放锁的操作

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

致异常结束。

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

不会释放锁的操作

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

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

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

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

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

4Lock：JDK5.0提出 : 代码块锁,性能较好
又称为显式锁 , 因为开启和关闭都是手动的
synchronized是隐式锁,因为执行完自动解锁

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同

步锁对象来实现同步。同步锁使用Lock对象充当。

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

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

5定时器

6死锁

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

7线程通信

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() {