Thread（26）
1、进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。
2、线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。
3、多线程：具有多个执行代码路径。
4、Thread类是一个标准的线程对象。两个路径，两个线程，在抢夺CPU资源（时间）。
5、创建线程步骤：
1、定义一个类继承Thread。
2、重写 run 方法。
3、创建子类对象，就是创建线程对象。
4、使用start方法，开启线程并让线程执行，同时还会告诉JVM去调用run方法。
6、定义类实现Runnable接口：
public class Demo02 { public static void main(String[] args) { //创建线程执行目标类对象 Runnable runn = new MyRunnable(); //将Runnable接口的子类对象作为参数传递给Thread类的构造函数 Thread thread = new Thread(runn); Thread thread2 = new Thread(runn); //开启线程 thread.start(); thread2.start(); for (int i = 0; i < 10; i++) { System.out.println("main线程：正在执行！"+i); } } }
class MyThread extends Thread { //继承Thread MyThread(String name){ super(name); } //复写其中的run方法 public void run(){ for (int i=1;i<=20 ;i++ ){ System.out.println(Thread.currentThread().getName()+",i="+i); } } } class ThreadDemo { public static void main(String[] args) { //创建两个线程任务 MyThread d = new MyThread(); MyThread d2 = new MyThread(); d.run();//没有开启新线程, 在主线程调用run方法 d2.start();//开启一个新线程，新线程调用run方法 } }
7、 自定义线程执行任务类：
public class MyRunnable implements Runnable{ //定义线程要执行的run方法逻辑 @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println("我的线程：正在执行！"+i); } } }
8、为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？
实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。
创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。
9、线程的匿名内部类使用。
方式1：创建线程对象时，直接重写Thread类中的run方法。
new Thread() { public void run() { for (int x = 0; x < 40; x++) {
System.out.println(Thread.currentThread().getName() + "...X...." + x); } } }.start();
方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法。
Runnable r = new Runnable() { public void run() { for (int x = 0; x < 40; x++) { System.out.println(Thread.currentThread().getName() + "...Y...." + x); } } }; new Thread(r).start();
10、线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
作用：线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。
11、 使用线程池中线程对象的步骤：
1、创建线程池对象。
2、 创建Runnable接口子类对象。
3、提交Runnable接口子类对象。
4、关闭线程池。
public class ThreadPoolDemo { public static void main(String[] args) { //创建线程池对象 ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象 //创建Runnable实例对象 MyRunnable r = new MyRunnable(); //自己创建线程对象的方式 //Thread t = new Thread(r); //t.start(); ---> 调用MyRunnable中的run() //从线程池中获取线程对象,然后调用MyRunnable中的run() service.submit(r); //再获取个线程对象，调用MyRunnable中的run() service.submit(r); service.submit(r); //注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中 //关闭线程池 //service.shutdown(); } } //Runnable接口实现类: public class MyRunnable implements Runnable { @Override public void run() { System.out.println("我要一个教练"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("教练来了： " +Thread.currentThread().getName()); System.out.println("教我游泳,交完后，教练回到了游泳池"); } }
12、静态方法内不允许直接调非静态的方法。栈内存，都是线程私有的。
13、Thread.currentThread() 获取当前线程对象，也就是说运行在本类中run 方法所对应的线程对象。方法调用链：Thread.currentThread() .getName() 获取当前线程对象的名字。
14、Thread对象方法：sleep(毫秒参数a) /// 线程睡觉a毫秒自动醒来再接着执行代码。
15、第二种方式Runnable实现线程的好处：避免了单继承的局限性。更加的符合面向对象。较为常用。实现Runnable接口，将线程任务单独分离出来封装成对象，类型呢就是Runnable接口类型，Runnable接口对线程对象和线程任务进行解耦。还有另一个好处就是：让你的资源能够共享。
public class RunnableDemo implements Runnable{ public RunnableDemo() { super(); } public void run(){ for(int i=0;i<1;i++){ try{ Thread.sleep(1000); }catch(Exception ex){} System.out.println("runnable"+i); } } }
16、高内聚：自己的事情自己做，自己能做的事情绝不让外面的人去做。 低耦合：尽量降低类与类之间的联系性。而接口的应用就恰好帮你完成这件事。
17、线程的生命周期：new - runnable - blocked （受阻塞） - waiting - time waiting - terminated (结束)
18、线程生命周期图解：
19、线程池（缓冲池）：
20、从JDK5以后，就内置了线程池技术，直接使用。
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoll { public static void main(String[] args) { ExecutorService es = Executors.newFixedThreadPool(2); es.submit(new ThreadPollRunnable()); es.submit(new ThreadPollRunnable()); es.submit(new ThreadPollRunnable()); } }
21、Runnable接口方法run有两个缺点：1、 无返回值 void。 2、 不能抛异常。 Callable接口就能解决这个问题。
22、父类有抛出异常，子类可抛可不抛出异常。
23、泛型不能写基本类型，要写基本类型的包装类，否则会报错误 “Syntax error, insert "Dimensions" to complete ReferenceType”。
24、双线程求和 Callable接口实现类泛型。
import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class ThreadPoll { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService es = Executors.newFixedThreadPool(2); Future<Integer> ft1 = es.submit(new CallableDemo(100)); Future<Integer> ft2 = es.submit(new CallableDemo(200)); System.out.println("sum1 "+ ft1.get()); System.out.println("sum2 "+ ft2.get()); es.shutdown(); } }
import java.util.concurrent.Callable; public class CallableDemo implements Callable<Integer>{ private int a; public CallableDemo(int num){ a = num; } public Integer call(){ int i = a; int sum = 0; while(i > 0){ sum = sum + i; i--; } return sum; } }
25、多线程同时操作一个共享数据的时候，往往会出现线程安全问题。（多窗口卖票案例中，判断有票情况下，没减减就被别的线程抢去资源了（失去CPU时间），等获得CPU时间的时候，再执行往下的代码就会出现问题。）
26、同步代码块解决线程安全问题。 线程共享数据，保证安全，加入同步代码块 synchronized（任意对象）{ 线程要操作的共享数据 } 同步代码块 =》 线程安全就意味着运行速度必然降低。牺牲速度来保证安全！ 安全问题的前提条件是：多线程，操作共享数据。
27、同步保证安全性：同步锁（对象监视器）的原理：
28、同步方法： StringBuffer类（线程安全）的方法都是同步方法 synchronized. 而它兄弟 StringBuiilder是线程不安全的，类中方法没有同步方法。
public class Tickets implements Runnable { private int ticket = 100; public void run (){ while(true){ saleTicket(); } } public synchronized void saleTicket(){ if(ticket > 0){ try{ Thread.sleep(10); }catch(Exception ex){} System.out.println(Thread.currentThread().getName()+"售出第"+ ticket-- + "张票~"); } } }
29、静态优先于非静态的存在。静态方法内不能引用非静态的成员变量等。
30、静态方法的同步锁是：本类类名.class 非静态方法的同步锁就是 this
31、JDK1.5新特性 Lock 比 synchronized 更加地灵活， 获取锁和释放锁地操作都能看见。
32、线程的死锁原理：(两人抓头发，你等着我松手，我等着你松手)
代码实现：
public class DeadLock implements Runnable{ private int i = 0; public void run(){ while(true){ if(i % 2 == 0){ //先进入A同步，再进入B同步 synchronized(LockA.locka){ System.out.println("if...locka"); synchronized(LockB.lockb){ System.out.println("if...lockb"); } } }else{ //先进入B同步，再进入A同步 synchronized(LockB.lockb){ System.out.println("else...lockb"); synchronized(LockA.locka){ System.out.println("else...locka"); } } } i++; } } }
33、线程等待与唤醒案例安全解决：一切为了不出现人妖问题。 问题产生原因：赋值时被抢夺了CPU时间，导致后半部分的赋值未完成就被打印值。
解决方案1：synchronized（唯一的对象）{ 共享数据代码块 }
解决方案2：使用线程间的通信方法 .wait() 与 .notify()
====》 .wait() 与 notify（） 方法。
