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
     
       ft1 = es.submit(new CallableDemo(100));        Future
      
        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
     
      {    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（）  方法。