Java 多线程

// 使当前线程让步，重新回到争夺CPU执行权的队列中
// 这个API只是一个标志，具体还得看底层怎么实现
// 实际上好像也没有合适的使用场景。
static void yield();

// 使当前正在执行的线程停留指定的毫秒数
static void sleep(long ms);

// 等被调用的这个线程执行结束后再执行当前线程
// 如果自己调用自己的join()方法会造成死锁
void join();

// 中断线程执行。实际上并不会立刻中断线程的执行，只是将中断标志设置为true
// 线程可以通过 Thread.currentThread().isInterrupted()来检查这个标志自己决定退出还
// 是继续执行。类似的API是stop(),可以立即中断线程，但是可能会导致不可预知的错误和资源未释
// 放等问题。已经不推荐这样使用。
void interrupt();

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Test {
    public static void main(String[] args) throws IOException {
        /*定义管道字节流*/
        PipedInputStream  inputStream = new PipedInputStream();
        PipedOutputStream outputStream = new PipedOutputStream();

        inputStream.connect(outputStream);

        /*创建两个线程向管道流中读写数据*/
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    writeData(outputStream);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
      
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    readData(inputStream);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }
    /**
     * 定义方法向管道流中写入数据
     */
    public static void writeData(PipedOutputStream out) throws IOException {
        /*把0-100 之间的数写入管道中*/
        for (int i = 0; i < 100; i++) {
            String data = "-" + i;
            out.write(data.getBytes()); //把字节数组写入到输出管道流中
        }
        out.close();
    }

    /**
     * 定义方法从管道中读取数据
     */
    public static void readData(PipedInputStream input) throws IOException {
        /*从管道中读取0-100*/
        byte[] bytes = new byte[1024];
      //返回读到的字节数，如果没有读到任何数据返回-1
        while(input.read(bytes) != -1){
            //把bytes数组中从0开始到len个字节转换为字符串打印出来
            System.out.println(new String(bytes,0,len));
        }
        input.close();
    }
}

public class Singleton {

    private static Singleton instance = null;

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    // new Singleton()过程可以分为3步
                    // 1、为Singleton对象分配内存空间
                    // 2、初始化Singleton对象
                    // 3、将instance指向Singleton的内存空间
                    // 指令重排之后可能的顺序是 1 => 3 => 2
                    // 在这种情况下A线程还没有完成初始化Singleton对象，B线程就可能直接使用instance，会出现问题
                    // 可以用volatile修饰保证原子性，防止指令重排
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public interface Lock {
    // 获得锁。 如果失败，则等待。如果成功，则必须主动释放，即使发生异常也不会释放锁
    // 所以必须按照try-catch-finally的形式，在finally中执行unlock()释放锁，防止死锁
    void lock();
  	
    void lockInterruptibly() throws InterruptedException;
  	
    // 尝试去获取锁，成功则返回true，失败则返回false。会立即返回，不会等待
    boolean tryLock();
    
    // 支持等待一段时间，超出时间之后未获取到锁则返回false，支持响应中断
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();
	
    // Condition中的await/signal/signalAll和wait/notify/notifyAll一样
    Condition newCondition();
}

// 读写锁，内部维护了两个锁，读锁共享，写锁排他。
public interface ReadWriteLock {
    // 返回读锁，当读锁被占用时，可以再次获得读锁，但是不能获得写锁
    Lock readLock();
    // 返回写锁
    Lock writeLock();
}

public ThreadPoolExecutor(
  int corePoolSize, 
  int maximumPoolSize,
  long keepAliveTime,
  TimeUnit unit,
  BlockingQueue<Runnable> workQueue,
  ThreadFactory threadFactory,
  RejectedExecutionHandler handler)