• wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当 前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有 权后才能继续执行。
• notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
• notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.

 这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。

 因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁,因此这三个方法只能在Object类中声明

wait() 方法

• 在当前线程中调用方法： 对象名.wait()
• 使当前线程进入等待(某对象)状态 ，直到另一线程对该对象发出 notify(或notifyAll) 为止。
• 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
• 调用此方法后，当前线程将释放对象监控权 ，然后进入等待
• 在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

notify()/notifyAll()

• 在当前线程中调用方法： 对象名.notify()
• 功能：唤醒等待该对象监控权的一个/所有线程。
• 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

JDK5.0 新增线程创建方式

新增方式一：实现Callable接口

与使用Runnable相比， Callable功能更强大些

•  相比run()方法，可以有返回值
•  方法可以抛出异常
•  支持泛型的返回值
•  需要借助FutureTask类，比如获取返回结果

•  可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
•  FutrueTask是Futrue接口的唯一的实现类
•  FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

新增方式二：使用线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

 好处：

•  提高响应速度（减少了创建新线程的时间）
•  降低资源消耗（重复利用线程池中线程，不需要每次都创建）
•  便于线程管理  corePoolSize：核心池的大小   maximumPoolSize：最大线程数   keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程池相关API

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

•  ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
•  void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
•  <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行 Callable
•  void shutdown() ：关闭连接池
•  Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
•  Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
•  Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
•  Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
•  Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

总结

package com.jyc.p1;

import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;

/*
栗子：创建三个窗口卖票，总票为100张，使用实现 Runnable 接口的方式
    1.问题卖票过程中，出现了重票，错票---》线程安全问题
    2.问题出现的原因：在某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
    3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程a操作完 ticket 时
其他线程才可以开始操作 ticket，这种情况线程a出现了阻塞，也不能被改变
    4.在java中我们通过同步机制，来解决线程的安全问题
        方式1.同步代码块
            synchronized (同步监视器){
                //需要被同步的代码
            }
          ①.操作共享数据的代码，即为需要同步的代码
          ②.共享数据，多个线程共同操作的变量，比如 ticket
          ③.同步监视器，俗称锁，任何一个类的对象，都可以充当锁(多个线程必须共用一把锁)
          ④ 在实现  Runnable 接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
       方式2.同步方法
            如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的
            同步方法仍是同步监视器，只是我们不需要显示的声明，
                非静态同步方法，同步监视器是this
                静态同步方法，同步监视器是当前类本身

     同步的方式，解决了线程的安全问题
     操作同步代码时，只能有一个线程参与，其他线程等待，相当于一个单线程的过程，效率低

    synchronized 与 lock 的异同
       相同：二者都可以解决线程安全问题
       不同 synchronized机制在执行完相应的同步代码以后，自动释放同步监视器
       lock 需要手动的启动同步lock，同时结束也需要手动释放unlock


* */
class window implements   Runnable{
    private    int ticket=100;
    Object obj= new Object();
//    方式一 ：同步代码块
//    public void run() {
//        //此时的this 唯一的window对象
//        synchronized (this){//synchronized (obj){
//        while (true){
//            if (ticket>0){
//                try {
//                    Thread.sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//                System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
//                ticket--;
//            }else{
//                break;
//            }
//        }
//    }
//
//    }

//    方式三
//    1.实例化ReentrantLock
    private ReentrantLock lock=new ReentrantLock();
    public void run() {
//        while (true){
//            show();
//        }

        while (true){
            try{
                //调用锁定方法lock（）
                lock.lock();

                if (ticket>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //调用解锁的方法unlock
                lock.unlock();
            }
        }
    }

    //方式二 同步方法
    private synchronized void  show(){ //同步监视器 this
        if (ticket>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖票，票号为："+ticket);
                ticket--;
            }
    }
}
/*
* 单例模式 懒汉式
*
* */
class  Bank{
    private  Bank(){}
    private  static  Bank
            instance=null;
    //方式一.同步监视器为 Bank.class 类也为对象
//    public  static synchronized Bank getInstance(){
//        if (instance==null){
//            instance=new Bank();
//
//        }
//        return  instance;
    public  static  Bank getInstance(){
        if (instance==null){
            synchronized (Bank.class){
             if (instance==null){
                 instance=new Bank();
           }
       }
   }
        return  instance;
    }
}
/*
* 线程通讯的例子
* 涉及到三个方法
* wait（） 一但执行此方法线程就进入阻塞状态，并释放同步监视器
* notify（） 一但执行次此方法，就会唤醒wait的一个线程，如果有多个线程被wait就唤醒优先级高的那个
* notifyAll 一但执行次此方法，就会唤醒wait的所有线程
* 说明 wait notify notifyAll 这三个方法必须使用在同步代码块或同步方法中
*       三个方法的调用者必须是同步代码块，或同步方法中的同步监视器
*       定义在object中
*
* sleep 和 wait 的异同
*  相同点 一但 执行方法，都可以使当前线程进入阻塞状态，
*  不同点 1.两个方法声明的位置不同，Thread类中声明的sleep，object类中声明的wait
*         2. 调用的要求不同，sleep可以在任何场景下调用，wait方法必须使用在同步代码块或者同步方法中
*         3.关于是否释放同步监视器，如果两个方法都使用在同步代码块，或同步方法中，sleep（）不会释放锁
*          wait（）会释放锁
*
*
* */
class   Number implements  Runnable{
    private  int number=1;
    public void run() {
        while (true){
           synchronized (this){
               notify();
               if (number<=100){
                   try {
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println(Thread.currentThread().getName()+" : "+number);
                   number++;
                   try {
                       //使得调用如下wait（）方法的线程进入阻塞状态
                       wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }else{
                   break;
               }
           }

        }
    }
}

/*
*创建线程的方式三 实现 Callable 接口
*   如何理解实现 Callable接口的方式 比实现 Runnable 接口创建多线程的方式强大
*      call（）可以有返回值
*      call（）可以抛出异常
*      Callable 支持泛型
*
*
* */
//创建一个实现了 Callable 的实现类
class NumThread implements Callable{
    //实现call方法 将此线程需要执行的操作声明在call方法中

    @Override
    public Object call() throws Exception {
        int sum=0;
        for (int i = 1; i <=100 ; i++) {
            if(i%2==0){
                sum+=i;
            }
        }
        return  sum;
    }
}
/*

* */
public class Shkstart {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //演示线程安全问题------------
//        window w=new window();
//     Thread t1 =new Thread(w);
//        Thread t2 =new Thread(w);
//        Thread t3 =new Thread(w);
//        t1.setName("窗口一");
//        t2.setName("窗口二");
//        t3.setName("窗口三");
//        t1.start();
//        t2.start();
//        t3.start();
        //线程通讯的演示----------
//        Number number=new Number();
//        Thread t1=new Thread( number);
//        Thread t2=new Thread( number);
//        t1.setName("线程一");
//        t2.setName("线程二");
//        t1.start();
//        t2.start();

//        *创建线程的方式三 实现 Callable 接口---------------
        //3.创建实现Callable接口实现类的对象
        NumThread numThread=new NumThread();
        //4.将此Callable接口实现的对象 传递到 FutureTask 构造器中 创建 FutureTask 对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将 FutureTask的对象作为参数 传递到 Thread类的构造器中并调用start
       new Thread(futureTask).start();
        Object sum= futureTask.get();
        //6.获取 Callable中 call方法的返回值
        System.out.println(sum);

//        * 创建线程的方式四 使用线程池
        // 提高响应速度（减少了创建新线程的时间）
        // 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
        // 便于线程管理
        // corePoolSize：核心池的大小
        // maximumPoolSize：最大线程数
        // keepAliveTime：线程没有任务时最多保持多长时间后会终止

        //1.提供指定线程数量的线程池
        ExecutorService service=Executors.newFixedThreadPool(10);
//        设置线程池的属性

        //2.执行指定线程的操作实现 Callable或 Runnable 的对象
//        service.submit()
//        service.execute();
        //3.关闭链接池
        service.shutdown();
    }
}