java并发控制常用api

1. sleep(long millis)

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），属于Thread类中的方法。 在调用sleep()方法的过程中，线程不会释放对象锁。依然持有着锁入眠，也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。等待睡眠时间到了之后进入线程进入就绪状态。 sleep()可以使低优先级的线程得到执行的机会，当然也可以让同优先级、高优先级的线程有执行的机会。

2. wait()和notify()、notifyAll()

三个方法都是Object类中的方法， 这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用。synchronized关键字用于保护共享数据，阻止其他线程对共享数据的存取，但是这样程序的流程就很不灵活了，如何才能在当前线程还没退出synchronized数据块时让其他线程也有机会访问共享数据呢？此时就用这三个方法来灵活控制。 

常用的wait方法有wait()和wait(long timeout);

void wait()  wait方法与sleep方法相同之处是在于都是让线程进入等待的状态，的与sleep方法不同之处在于：使用wait方法进入等待的线程会主动释放持有的锁。 在其他线程调用此对象的 notify()  方法或者 notifyAll() 方法前，导致当前线程等待。 注意：notify不会释放锁 

void wait(long timeout) 在其他线程调用此对象的notify() 方法 或者 notifyAll()方法，或者超过指定的时间量前，导致当前线程等待。 

wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其他 synchronized 数据可被别的线程使用。 wait() 和 notify() 因为会对对象的“锁标志”进行操作，所以他们必需在 Synchronized 函数或者  synchronized block  中进行调用 。如果在non-synchronized 函数或 non-synchronized block 中进行调用， 虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常 。

在生产者与消费者的场景中，要使用notifyAll而不是用notify，notify会导致死锁出现。

3. yield()

是Thread中的方法。 暂停当前正在执行的线程对象，并执行其他线程。 该方法与sleep()类似，只是不能由用户指定暂停多长时间，并且yield（）方法只能让同优先级的线程有执行的机会。 但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。 yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

package com.multithread.yield;  
class ThreadYield extends Thread{  
    public ThreadYield(String name) {  
        super(name);  
    }  
   
    @Override  
    public void run() {  
        for (int i = 1; i <= 50; i++) {  
            System.out.println("" + this.getName() + "-----" + i);  
            // 当i为30时，该线程就会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）  
            if (i ==30) {  
                this.yield();  
            }  
        }  
      
}  
}  
  
public class Main {  
  
    public static void main(String[] args) {  
          
        ThreadYield yt1 = new ThreadYield("张三");  
        ThreadYield yt2 = new ThreadYield("李四");  
        yt1.start();  
        yt2.start();  
    }  
  

运行结果：

第一种情况：李四（线程）当执行到30时会CPU时间让掉，这时张三（线程）抢到CPU时间并执行。

第二种情况：李四（线程）当执行到30时会CPU时间让掉，这时李四（线程）抢到CPU时间并执行。

sleep()和yield()的区别

        sleep()和yield()的区别):sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

        sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程

       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。 

4. join()

join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

使用时的代码： Thread t =  new  AThread(); t.start(); t.join();  

为什么要用join()方法

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

不加join。

package com.multithread.join;  
class Thread1 extends Thread{  
    private String name;  
    public Thread1(String name) {  
        super(name);  
       this.name=name;  
    }  
    public void run() {  
        System.out.println(Thread.currentThread().getName() + " 线程运行开始!");  
        for (int i = 0; i < 5; i++) {  
            System.out.println("子线程"+name + "运行 : " + i);  
            try {  
                sleep((int) Math.random() * 10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        System.out.println(Thread.currentThread().getName() + " 线程运行结束!");  
    }  
}  
  
public class Main {  
  
    public static void main(String[] args) {  
        System.out.println(Thread.currentThread().getName()+"主线程运行开始!");  
        Thread1 mTh1=new Thread1("A");  
        Thread1 mTh2=new Thread1("B");  
        mTh1.start();  
        mTh2.start();  
        System.out.println(Thread.currentThread().getName()+ "主线程运行结束!");  
  
    }  
  
}  

输出结果：

main主线程运行开始!

main主线程运行结束!

B 线程运行开始!

子线程B运行 : 0

A 线程运行开始!

子线程A运行 : 0

子线程B运行 : 1

子线程A运行 : 1

子线程A运行 : 2

子线程A运行 : 3

子线程A运行 : 4

A 线程运行结束!

子线程B运行 : 2

子线程B运行 : 3

子线程B运行 : 4

B 线程运行结束!

发现主线程比子线程早结束

加join

public class Main {  
  
    public static void main(String[] args) {  
        System.out.println(Thread.currentThread().getName()+"主线程运行开始!");  
        Thread1 mTh1=new Thread1("A");  
        Thread1 mTh2=new Thread1("B");  
        mTh1.start();  
        mTh2.start();  
        try {  
            mTh1.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        try {  
            mTh2.join();  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println(Thread.currentThread().getName()+ "主线程运行结束!");  
  
    }  
  
}  

运行结果：

main主线程运行开始!

A 线程运行开始!

子线程A运行 : 0

B 线程运行开始!

子线程B运行 : 0

子线程A运行 : 1

子线程B运行 : 1

子线程A运行 : 2

子线程B运行 : 2

子线程A运行 : 3

子线程B运行 : 3

子线程A运行 : 4

子线程B运行 : 4

A 线程运行结束!

主线程一定会等子线程都结束了才结束

5. await、signal、signalAll

Condition类中的方法，相对于wait/notify来说，await/signal方法可以用来更准确的指定叫醒哪些线程。在使用时，同样也是要先获取对象的锁。

5. run和start()

把需要处理的代码放到run()方法中，start()方法启动线程将自动调用run()方法，这个由java的内存机制规定的。并且run()方法必需是public访问权限，返回值类型为void。

6. Callable接口和Runnable接口的区别

两个接口非常相似，Callable接口内只有一个call方法，用于定义一个线程执行的操作；Runnable接口内只有一个run方法，也是用于线程执行的操作。区别在于call方法是带返回值的，而run方法是不带返回值的。且call方法是可以抛出异常的，而run方法是没有的。