一、线程池
1.概念：
线程池，其实就是一个容纳多个线程的容器，其中的线程可以重复使用，省去了频繁创建线程对象的过程，无需反复创建线程而消耗过多资源，是JDK1.5以后出现的。
2.使用线程池的方式—-Runnable接口
线程池是由线程池工厂创建的，再调用线程池中的方法调用线程，再通过线程去执行任务方法。
构造代码：2.1 Executors：线程池创建工厂类
2.2 ExecutorService：线程池类 Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行
2.3 Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
创建线程池的步骤：
1.创建线程池对象
2.创建Runnable接口子类对象
3.提交Runnable接口子类对象
4.关闭线程池
Runnable接口实现类：
package com.oracle.Demo01; public class MyRunnable implements Runnable{ //Runnable接口实现类，并且有线程任务 @Override public void run() { for(int i=0;i<100;i++){ System.out.println(Thread.currentThread().getName()+":"+i); } } }
线程池代码：
package com.oracle.Demo01; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; //Executor创建线程池方法 public class Demo01 { public static void main(String[] args) { // 1.通过线程池工厂 获得线程池对象 ExecutorService es=Executors.newFixedThreadPool(5); //2.获得线程对象并提交 es.submit(new MyRunnable()); es.submit(new MyRunnable()); //销毁线程池：执行完毕后，销毁线程池，线程也就进入死亡状态了 //若不销毁，线程运行完毕又回到线程池，回到新建状态，没有进入死亡状态 es.shutdown(); } }
3.使用线程池方法—–Callable接口
构造代码：3.1 Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。
3.2 ExecutorService：线程池类
<T> Future<T> submit(Callable<T> task)：获取线程池中的某一个线程对象，并执行线程中的call()方法
3.3 Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用
使用线程池中线程的步骤：
1.创建线程池对象
2.创建Callable接口子类对象
3.提交Callable接口子类对象
4.摧毁线程池
Callable接口实现类代码：
package com.oracle.Demo01; import java.util.concurrent.Callable; //创建Callable接口的子类，并且有线程任务 public class MyCcallable implements Callable<String>{ @Override public String call() throws Exception { System.out.println("Call方法"); return "abc"; } }
线程池运行代码：
package com.oracle.Demo01; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; //使用Callable方法使用线程池的线程 public class Demo02 { public static void main(String[] args) throws InterruptedException, ExecutionException { // TODO Auto-generated method stub ExecutorService es=Executors.newFixedThreadPool(3); Future<String> f=es.submit(new MyCcallable()); String s=f.get(); System.out.println(s); } }
二、多线程
1.线程安全：
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
比如电脑端，手机端，跟售票窗口同时卖一张票，因为是多线程所以是同时进行的，当一个线程买到票后，可能另外两个线程也进行到一半了，但是因为已经没有票了，所以就会出现异常错误，比如重复的票号或异常的票号，这就是出现了线程安全问题。
2.线程同步：
Java中提供了线程同步机制，来解决线程安全的问题。
线程同步的方式有两种：
1.同步代码块
2.同步方法
2.1同步代码块：
在代码块声明上，加上synchronized
synchronized (锁对象) { 可能会产生线程安全问题的代码 }
同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。
多线程代码：
package com.oracle.Demo02; public class Demo { public static void main(String[] args) { Tickets t=new Tickets(); Thread t0=new Thread(t); Thread t1=new Thread(t); Thread t2=new Thread(t); t0.start(); t1.start(); t2.start(); } }
使用同步代码块：
package com.oracle.Demo02; //卖票任务 //synchronized(任意对象){ // 线程要操作的共享数据 //} //同步代码块解决线程不安全的原理： // 线程遇到同步代码块时，线程会先判断你的同步锁有没有，如果有，就获取同步锁，进入同步去执行代码，执行完毕后， //再把锁还回去。 // 在同步中，线程进行了休眠，此时另一个线程会执行，遇到同步代码块的时候，会判断同步锁有没有，如果没有， //没有获取到同步锁的线程，不能进入同步去执行，被阻挡在同步代码块外面 public class Tickets implements Runnable{ private int ticket=100; //private Object obj=new Object(); public void run() { while(true){ synchronized (this) { //这里的this 可以为任意对象，替换成上面的obj也可以，为自身对象this也可以 if(ticket>0){ try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"出售第"+(ticket--)+"张票"); } } } } }
2.2 同步方法
在方法声明上，加上synchronized
public synchronized void method(){ 可能会产生线程安全问题的代码 }
同步方法中的锁对象是 this
多线程代码：
package com.oracle.Demo03; public class Demo { public static void main(String[] args) { Tickets t=new Tickets(); Thread t0=new Thread(t); Thread t1=new Thread(t); Thread t2=new Thread(t); t0.start(); t1.start(); t2.start(); } }
使用同步代码块：
package com.oracle.Demo03; public class Tickets implements Runnable{ private int ticket=100; public void run() { while(true){ method(); } } //同步方法：解决线程不安全问题 //问题1：同步方法有锁吗？有，锁是本类引用，this关键字 //问题2：如果你的同步方法是静态的，还有同步锁吗?是this吗？ //有，不是this，是本类自己，Tickets.class public synchronized void method(){ if(ticket>0){ try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"出售第"+(ticket--)+"张票"); }else{ return; } } }
静态同步方法: 在方法声明上加上static synchronized
public static synchronized void method(){ 可能会产生线程安全问题的代码 }
使用同步方法：
package com.oracle.Demo03; public class Tickets implements Runnable{ private int ticket=100; public void run() { while(true){ method(); } } //同步方法：解决线程不安全问题 //问题1：同步方法有锁吗？有，锁是本类引用，this关键字 //问题2：如果你的同步方法是静态的，还有同步锁吗?是this吗？ //有，不是this，是本类自己，Tickets.class public synchronized void method(){ if(ticket>0){ try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"出售第"+(ticket--)+"张票"); }else{ return; } } }
2.3死锁
同步锁使用的弊端：当线程任务中出现了多个同步锁(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。
synchronzied(A锁){ synchronized(B锁){ } }
所以，不能在一个同步中再嵌套另一个同步
2.4 Lock接口
Lock 实现类提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
常用方法：
Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。
package com.oracle.Demo04; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; //Lock接口 public class Tickets implements Runnable{ private int ticket=100; private Lock lock=new ReentrantLock(); //创建一个锁的对象 public void run() { while(true){ lock.lock(); //提供锁 if(ticket>0){ try { Thread.sleep(10); System.out.println(Thread.currentThread().getName()+"出售第"+(ticket--)+"张票"); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally{ lock.unlock(); //执行完毕释放锁 } } } } }
2.5等待唤醒机制
线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。
等待唤醒机制的方法：
wait():等待。将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。
notify():唤醒。唤醒线程池中被wait()的线程，一次只能唤醒一个，而且是随机的任意线程。
notifyAll():唤醒全部。可以将线程池中所有被wait()的线程唤醒。
所谓唤醒的意思就是让线程池中的线程具备执行资格。必须注意的是，这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁，
这样才可以明确出这些方法操作的到底是哪个锁上的线程。
等待唤醒示例图：
自定义实体类：
package com.oracle.Demo06; //等待唤醒机制 自定义实体类 public class Resource { public String name; public String sex; public boolean flag=false; }
线程类：
package com.oracle.Demo06; public class Input implements Runnable{ private Resource r; public Input(Resource r){ this.r=r; } public void run() { int i=0; while(true){ synchronized(r){ if(r.flag){ try { r.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } if(i%2==0){ r.name="张三"; r.sex="男"; }else{ r.name="lisi"; r.sex="nv"; } i++; } r.flag=true; r.notify(); } } } }
package com.oracle.Demo06; public class Output implements Runnable{ private Resource r; public Output(Resource r){ this.r=r; } //flag:当flag为true的时候，代表赋值完成 //为false,获取值完成 public void run() { while(true){ synchronized (r) { if(!r.flag){ try { r.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(r.name+"..."+r.sex); r.flag=false; r.notify(); } } } }
测试类：
package com.oracle.Demo06; public class Output implements Runnable{ private Resource r; public Output(Resource r){ this.r=r; } //flag:当flag为true的时候，代表赋值完成 //为false,获取值完成 public void run() { while(true){ synchronized (r) { if(!r.flag){ try { r.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(r.name+"..."+r.sex); r.flag=false; r.notify(); } } } }
