428 线程的生命周期

429 理解线程的安全问题

1.线程的同步

1、提出问题： 多个线程执行的不确定性引起执行结果的不稳定

​ 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。

430 线程安全问题的举例和解决措施

例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式

1.问题：卖票过程中，出现了重票，错票----出现了线程的安全问题

2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票

3.如何解决：当一个线程在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变

431 同步代码块处理实现Runnable的线程安全问题

4.在java中，通过同步机制，来解决线程的安全问题

  方式一：同步代码块

     synchronized(同步监视器){

          //需要被同步的代码

    }

    说明：1.操作共享数据的代码，即为需要被同步的代码---不能包含代码多了，也不能包含代码少了

               2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据

               3.同步监视器：俗称：锁。任何一个类的对象，都可以充当锁

                         要求：多个线程必须要共用同一把锁

              补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

  方式二：同步方法

5.同步的方式，解决了线程的安全问题----好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低--局限性

432 同步代码块处理继承Thread类的线程安全问题

说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器

/ * 使用同步代码块解决继承Thread类的方式的线程安全问题 * * 例子：创建三个c窗口卖票，总票数为100张 */class Windows extends Thread{    private static int ticket = 100;    private static Object obj = new Object();    @Override    public void run() { while(true){     //正确的//     synchronized (obj) {     synchronized (Windows.class){   //Class clazz = Windows.class     //错误的，因为此时this表示的是t1,t2,t3三个对象//     synchronized (this) {  if (ticket > 0) {      try {   Thread.sleep(100);      } catch (InterruptedException e) {   e.printStackTrace();      }      System.out.println(getName() + ":卖票，票号为: " + ticket);      ticket--;  } else {      break;  }     } }    }}public class WindowsTest2 {    public static void main(String[] args) { Windows t1 = new Windows(); Windows t2 = new Windows(); Windows t3 = new Windows(); t1.setName("窗口1"); t2.setName("窗口2"); t3.setName("窗口3"); t1.start(); t2.start(); t3.start();    }}

433 同步方法处理实现Runnable的线程安全问题 

方式二：同步方法

      如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的

 同步监视器：this

434 同步方法处理继承Thread类的线程安全问题

关于同步方法的总结：

1，同步方法仍然涉及到同步监视器，只是不需要我们显式的声明

2，非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类本身

435 线程安全的单例模式之懒汉式

使用同步机制将单例模式中的懒汉式改写为线程安全的

public class BankTest{}class Bank{    private Bank(){}    private static Bank instance=null;    public static  Bank getInstance(){//方式一：效率稍差synchronized(Bank.class){  if(instance==null){     instance=new Bank();  }  return instance;}//方式二：效率更高if(instance==null){synchronized(Bank.class){  if(instance==null){   instance=new Bank();  } }}  return instance;}    }

436 死锁的问题 

1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，
     都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
 2.说明:
    》出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
    》我们使用同步时，要避免出现死锁。

public class ThreadTest{   public static void main(String[] args){StringBuffer.s1=new StringBuffer();StringBuffer.s2=new StringBuffer();new Thread(){     public void run(){ synchroized(s1){    s1.append("a");    s2.append("1");    try{Thread.sleep(millis:100);    }catch(InterruptedExpection e){e.printStackTrace();    }    synchronized(s2){s1.append("b");s2.append("2");System.out.println(s1);System.out.println(s2);     }   }.start();   new Thread(new Runnable(){   public void run(){     synchroized(s2){    s1.append("c");    s2.append("3");    try{Thread.sleep(millis:100);    }catch(InterruptedExpection e){e.printStackTrace();    }    synchronized(s1){s1.append("d");s2.append("4");System.out.println(s1);System.out.println(s2);      }      }     }  }).start();   }}

437 Lock锁方式解决线程安全问题 

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了Lock ，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
 

class Window implements Runnable{     private int ticket=100;     //1.实例化ReentrantLock     private ReentrantLock lock=new ReentrantLock(fair:true);     public void run(){   while(true){ try{    //2.调用锁定方法lock()    lock.lock();   if(ticket>0){ try{    Thread.sleep(millis:100); }catch(InterruptedExpection e){     e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+":售票，票号为："+ticket);  ticket--; }else{   break;}   }finally{//3.调用解锁方法：unlock()lock.unlock();   }  }  }}public class LockTest{    public static void main(String[] args){   Window w=new Window();   Thread t1=new Thread(w);   Thread t2=new Thread(w);   Thread t3=new Thread(w);   t1.setName("窗口1");   t2.setName("窗口2");   t3.setName("窗口3");   t1.start();   t2.start();   t3.start();}}

 1.面试题：synchronized与lock的异同

同：二者都可以解决线程安全问题

不同：synchronized机制在执行完相应的同步代码之后，自动的释放同步监视器

2.优先使用顺序：

Lock---同步代码块（已经进入了方法体，分配了相应资源）----同步方法（在方法体之外）

面试题：如何解决线程安全问题，有几种方式

438 同步机制的课后练习

银行有一个账户。
 * 有两个储户分别向同一个账户存3000元，每次存1000，存3次。
 * 每次存完打印账户余额。
 *
 * 分析：
 *      1.是否是多线程问题？是，两个储户线程
 *      2.是否有共享数据？有，账户（或账户余额）
 *      3.是否有线程安全问题？有
 *      4.需要考虑如何解决线程安全问题？同步机制：有三种方式。
 

class Account{   private double balance;   public Account(double balance){ this.balance=balance;   }   //存钱   public synchroized void deposit(double amt){      if(amt>0){  balance+=amt;  try{  Thread.sleep(mills:1000);  }catch(InterruptedExpection e){      e.printStackTrace();  }  System.out.println(Thread.currentThread().getName()+":存钱成功，余额为："+balance);      }   }}class Customer extends Thread{   private Account acct;   public Customer(Account acct){      this.acct=acct;   }   public void run(){ for(int i=0;i<3;i++){      acct.deposit(amt:1000);      }   }}public class AccountTest{   public static void main(String[] args){     Account acct=new Account(balance:0);     Customer c1=new Customer(acct);     Customer c2=new Customer(acct);     c1.setName("甲");     c2.setName("乙");     c1.start();     c2.start();     }}

439 线程通信的例题

线程通信的例子：使用两个线程打印1-100。线程1, 线程2 交替打印

class Number implements Runnable{    private int number=1;    public void run(){  while(true){    synchronized(this){ notify();      if(number<=100){   try{Thread.sleep(millis:10);   }catch(InterruptedException e){e.printStackTrace();   }   System.out.println(Thread.currentThread().getName()+":"+number);   number++;   try{//使得调用如下wait()方法的线程进入阻塞状态wait();   }catch(InterruptedException e){e.printStackTrace();   }      }else{   break;      }    }  }    }}public class CommunicationTest{   public static void main(String[] args){     Number number=new Number;     Thread t1=new Thread(number);     Thread t2=new Thread(number);     t1.setName("线程1");     t2.setName("线程2");     t1.start();     t2.start();  }}

 涉及到的三个方法：

wait（）：一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器

notify（）：一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的那个

notifyAll（）：一旦执行此方法，就会唤醒被wait的一个线程

说明

1.wait（），notify（），notifyAll（）三个方法必须使用在同步代码块或同步方法中

2.wait（），notify（），notifyAll（）三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则会出现IllegalMonitorStateException异常

3.wait（），notify（），notifyAll（）三个方法是定义在java.lang.Object类中

440 sleep（）和wait（）的异同

面试题：sleep（）和wait（）的异同

1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态

2.不同点：

   1.两个方法声明的位置不同：Thread类中声明sleep（），Object类中声明wait（）

   2.调用的范围和要求不同：sleep（）可以在任何需要的场景下调用，wait（）必须在使用同步代码块或同步方法中

  3.关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep（）不释放锁，wait（）释放锁

441 生产者消费者例题

分析：

1.是否是多线程问题？是，生产者线程，消费者线程

2.是否有共享数据？是，店员（或产品）

3.如何解决线程的安全问题？同步机制，有三种方法

4.是否涉及到线程的通信？是

class Clerk{    private int productCount=0;    public synchronized void producePrdouct(){if(productCount0){      System.out.println(Thread.currentThread().getName()+"：开始消费第"+productCount);   productCount--;   notify();}else{   try{   wait();   }catch(InterruptedException e){e.printStackTrace();   }}    }}class Producer extends Thread{      private Clerk clerk;      public Producer(Clerk clerk){   this.clerk=clerk;      }      public void run(){   System.out.println(getName()+":开始生产产品");   while(true){ try{Thread.sleep(millis:10);}catch(InterruptedException e){     e.printStackTrace();}clerk.produceProduct();   }      }}class Consumer extends Thread{      private Clerk clerk;      public Consumer(Clerk clerk){   this.clerk=clerk;      }      public void run(){   System.out.println(getName()+":开始消费产品");   while(true){ try{Thread.sleep(millis:10);}catch(InterruptedException e){     e.printStackTrace();}clerk.consumeProduct();   }}public class ProductTest{    public static void main(String[] args){ Clerk clerk=new Clerk(); Produce p1=new Producer(clerk); p1.setName("生产者1"); Consumer p1=new Consumer(clerk); c1.setName("消费者1"); p1.start(); c1.start();  }}

442 实现Callable接口 

//1.创建一个实现callable的实现类class NumThread implements Callable{    //2.实现call方法，将此线程需要执行的操作声明在call（）中    public Object call() thorws Exception{  int sum=0;  for(int i=1;i<=100;i++){     if(i%2==0){  System.out.println(i);  sum+=i;     }  }  return sum;    }   }public class ThreadNew{      public static void main(String[] args){  //3.创建Callable接口实现类的对象  NumThread numThread=new NumThread();  //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象  FutureTask futureTask=new FutureTask(numThread);  //5.将futuretask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start（）  new Thread(futureTask).start();  try{     //6.获取Callable中call方法的返回值     //get()返回值即为FutureTask构造器参数callable实现类重写的call（）的返回值     Object sum=futureTask.get();     System.out.println("总和为："+sum);   }catch(InterruptedException e){e. printStackTrace();   }catch(ExecutionException e){e. printStackTrace();   }     }}  

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

1.call（）可以有返回值

2.call（）可以抛出异常，被外面的操作捕获，获取异常的信息

3.Callable是支持泛型的 

Future接口

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

443 线程池的好处

1、背景：

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

2、思路：

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

3、好处：

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

线程池相关API

JDK 5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
void shutdown()：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

444 使用线程池 

class NumberThread implements Runnable{    public void run(){for(int i=0;i<=100;i++){  if(i%2==0){System.out.println(Thread.currentThread().getName()+":"+i);  }}    }}public class ThreadPool{   public static void main(String[] args){      //1.提供指定线程数量的线程池      ExecutorService service=Executors.newFixedThreadPool(nThreads:10);      //2.执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象      service.execute(new NumberThread());//适合适用于Runnable      //service.submit();//适合适用于Callable      //关闭连接池      service.shutdown();   }}