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){  // 把该类中所有加锁的静态方法和代码块锁全部锁定
                      同步代码;
                 }

1. synchronized的锁是什么？

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

1. 注意：

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

无法保证共享资源的安全

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

释放锁的操作

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

致异常结束。

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

不会释放锁的操作

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

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

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

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

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

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

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

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

1. java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。
2. 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() {

System.out.println(Thread.currentThread().getName() + " : " + count);

count++;

// 唤醒所有在当前对象中睡眠的线程

this.notifyAll();

try {

Thread.sleep(500);

// 挂起 交出该对象持有的锁,让其他线程可以执行

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}