2022-08-03第七组姜珊学习笔记

线程

1.synchronized多线程并发编程。

​ 重量级锁。JDK1.6对synchronized进行了优化。

​ JDK1.6为了减少获得锁和释放锁带来的性能消耗引入的偏向锁和轻量级锁。

2.synchronized有三种方式来加锁，分别是：

1.修饰实例方法，作用于当前实例加锁，进入同步代码前要获得当前实例的锁

2.静态方法，作用于当前类对象加锁，进入同步代码前要获得的当前类对象的锁

3.代码块，指定加锁对象，对给定对象加锁，进入同步代码块之前要获得给定对象的锁

1.实例方法：调用该方法的实例

2.静态方法：类对象

3.this：调用该方法的实例对象

4.类对象：类对象 操作共享数据的代码

共享数据：多个线程共同操作的变量，都可以充当锁

​ 当使用同步方法时，synchronized锁的东西是this（默认的）

关于同步方法：

• 同步方法依然涉及到同步锁对象，不需要我们写出来

• 非静态的同步方法，同步锁就是this

• 静态的同步方法，同步监视器就是类本身
  同步代码块：

• 1.选好同步监视器（锁）推荐使用类对象，第三方对象，this

• 2.在实现接口创建的线程类中，同步代码块不可以用this来充当同步锁

  同步的方式，解决线程安全的问题。

  操作同步代码时，只有一个线程能够参与，其他线程等待。

  相当于一个单线程的过程，效率低。
  synchronized只针对于当前JVM可以解决线程安全问题。

  synchronized不可以跨JVM解决问题！！！

锁

• 死锁是这样一种情形：多个线程同时被阻塞，他们中的一个或者全部，都在等待某个资源的释放，由于线程无限期的阻塞，程序就不可能正常终止。

• java死锁产生四个必要条件

  1.互斥使用，当资源被一个线程使用（占用），别的线程不能使用。

  2.不可抢占，资源请求者不能强制从占有者中抢夺资源，资源只能从占有者手动释放

  3.请求和保持，

  4.循环等待，存在一个等待队列。P1占有P2的资源，P2占有了P3的资源

  P3占有P1的资源。形成了一个等待环路。
  lass LockA implements Runnable {
  @Override
  public void run() {
  System.out.println(new Date().toString() + "LockA开始执行...");
  try {
  while (true) {
  synchronized (Ch04.obj1) {
  System.out.println(new Date().toString() + "LockA锁住了obj1");

                Thread.sleep(8000);
            }
            synchronized (Ch04.obj2) {
                System.out.println(new Date().toString() + "LockA锁住了obj2");
                Thread.sleep(70*1000);
            }
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
  

  }
  }
  class LockB implements Runnable {

    @Override
    public void run() {
        System.out.println(new Date().toString() + "LockB开始执行...");
        try {
            while (true) {
                synchronized (Ch04.obj2) {
                    System.out.println(new Date().toString() + "LockB锁住了obj2");
                    Thread.sleep(6000); //3s
                }
                synchronized (Ch04.obj1) {
                    System.out.println(new Date().toString() + "LockB锁住了obj1");
                    Thread.sleep(100*1000); // 1min
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
  

  }
  public class Ch04 {
  public static String obj1 = "obj1";
  public static String obj2 = "obj2";

    public static void main(String[] args) {
        LockA lockA = new LockA();
        new Thread(lockA).start();
        LockB lockB = new LockB();
        new Thread(lockB).start();
    }
  

  }

线程重入

• 任意线程在拿到锁之后，再次获取该锁不会被该锁所阻碍

• 线程不会被自己锁死的。

  这就叫线程的重入，synchronized可重入锁。

• JDK1.6以后锁升级：

  1.无锁：不加锁

  2.偏向锁：不锁锁，只有一个线程争夺时，偏向某一个线程，这个线程不加锁

  3.轻量级锁：少量线程来了之后，向尝试自旋，不挂起线程。

  4.重量级锁：排队挂起（暂停）线程。（synchronized）

  挂起线程和恢复线程需要转入内核态中完成这些操作，给系统的并发性带来很大的压力。

  在许多应用上共享数据的锁定状态，只会持续很短的时间，为了这段时间去挂起和恢复并不值得，我们可以让后面的线程等待一下，不要放弃处理器的执行时间。锁为了让线程等待，我们只需要让线程，执行一个循环，自旋。【自旋锁】
  hashcode值1 0
  class Window implements Runnable {

  private static int ticket = 100;

  private String name;

  private static Object obj = new Object();

  public Window(String name) {
  this.name = name;
  }

  @Override
  public void run() {
  synchronized (Window.class) {
  while(true) {
  if(ticket > 0) {
  try {
  Thread.sleep(100);
  } catch (InterruptedException e) {
  throw new RuntimeException(e);
  }
  System.out.println(name + "卖票，剩余：" + ticket-- + "张！");
  }else {
  break;
  }
  }
  }
  }

  private synchronized void sell() {
  while(true) {
  if(ticket > 0) {
  try {
  Thread.sleep(100);
  } catch (InterruptedException e) {
  throw new RuntimeException(e);
  }
  System.out.println(name + "卖票，剩余：" + ticket-- + "张！");
  }else {
  break;
  }
  }
  }
  }

public class Ch02 {

public static void main(String[] args) {
    Thread t1 = new Thread(new Window("窗口一"));
    Thread t2 = new Thread(new Window("窗口二"));
    t1.start();
    t2.start();
}

}

Object类对多线程的支持

• wait():

• wait(long timeout):当前线程进入等待状态

• notify()：唤醒正在等待的下一个线程

• notifyAll()：唤醒正在等待的所有线程

  线程间的通信

  比如两条线程，共同运行。

  线程A如果先走，线程B就要等待。等待线程A走完，唤醒线程B，线程B再走

方法总结：

• Thread的两个静态方法：

• sleep释放CPU资源，但是不会释放锁

• yield方法释放CPU执行权，保留了CPU的执行资格，不常用。

• join方法，yield出让了执行权，join就加入进来。

• wait：释放CPU资源，释放锁

• notify：唤醒等待中的线程

• notifyAll：唤醒等待中的所有线程

  面试题：sleep和wait的区别？

  1.出处

  2.锁的控制

  线程的退出

  • 使用退出标志，线程正常退出，run方法结束后线程终止
  • 不要使用stop方法。
  • System.exit(-1)

interrupt方法

• 中断线程。
• 调用interrupt方法会抛出InterruptedException异常，
• 捕获后再做停止线程的逻辑即可。
• 如果线程while(true)运行的状态，interrupt方法无法中断线程

线程的常用方法：

Thread类中的方法

• 1.start：启动当前线程；执行run方法
• 2.run：
• 3.currentThread：静态方法，获取当前正在执行的线程
• 4.getId()：返回此线程的唯一标识
• 5.setName(String)：设置当前线程的name
• 6.getName()：获取当前线程的name
• 7.getPriority()：获取当前线程的优先级
• 8.setPriority(int)：设置当前线程的优先级
• 9.getState()：获取当前线程的声明周期
• 10.interrupt()：中断线程的执行
• 11.interrupted()：查看当前线程是否中断

懒汉式

class Singleton {
private static Singleton instant;

private Singleton(){}

public static Singleton getInstance() {
    if(instant == null) {
        // 卡了
        synchronized (Singleton.class) {
            if(instant == null){
                instant = new Singleton();
            }
        }
    }
    return instant;
}

// public static synchronized Singleton getInstance() {
// if(instant == null){
// instant = new Singleton();
// }
// return instant;
// }
}

public class Ch06 {

public static void main(String[] args) {
    System.out.println(Singleton.getInstance() == Singleton.getInstance());
}

}