多线程

（一）、进程、线程、多进程的概念
进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。
注意点：
1、一个进程中至少有一个线程。
2、一个进程中可以有多个执行路径，称之为多线程。
3、开启多个线程是为了同时运行多部分代码，每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

多线程的好处：解决了多部分代码同时运行的问题。
多线程的弊端：线程太多，会导致效率的降低。

什么是”并行”和”并发”：
1.”并行”是指逻辑上一起在执行，它强调的是在”同一段时间内”一起运行的程序；
2.”并发”是指物理上的抢占同一资源。它强调的是在”同一时刻时”一起抢占系统的某个共享资源；

（二）、线程的创建方式
创建线程方式一：继承Thread类
1. 定义一个类继承Thread类。
2. 覆盖Thread类中的run方法。
3. 直接创建Thread的子类对象创建线程。
4. 调用start方法开启线程并调用线程的任务run方法执行。

class Test extends Thread{    private String name;    public Test(String name)    {        this.name=name;    }    public void run()    {        for (int x=0;x<100 ;x++ )        {            System.out.println((Thread.currentThread()==this)+"----"+this.getName()+"run----"+x);        }    }}class ThreadTest{    public static void main(String[] args)    {        Test t1=new Test("xiaomi");        Test t2=new Test("liming");        t1.start();        t2.start();        for(int x=0;x<100;x++)        {            System.out.println("main------"+x);        }    }}

创建线程方式二：实现Runnable接口
1. 定义类实现Runnable接口。
2. 覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务。
4. 调用线程对象的start方法开启线程。

实现Runnable接口的好处：
1. 将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
2. 避免了Java单继承的局限性。所以，创建线程的第二种方式较为常用。

class Demo implements Runnable{      public void run(){            show();      }      public void show(){             for(int x = 0; x < 100; x++){                  System.out.println(Thread.currentThread().getName() + "---" + x);             }      }}class ThreadDemo{       public static void main(String[] args){            Demo d = new Demo();            Thread t1 = new Thread(d);            Thread t2 = new Thread(d);            t1.start();            t2.start();       }}

（三）、线程安全问题
线程安全问题产生的原因?
1. 多个线程在操作共享的数据。
2. 操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。
线程安全问题的解决方案?
将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程不可以参与运算。必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。
格式有两种：
synchronized(对象){
需要被同步的代码;
}
在函数上加上synchronized修饰符
很好的解决了线程安全问题，但是同步的弊端是当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
需求：储户，两个，每个都到银行存钱，每次存100，共存三次。

class Bank{       private int sum ;       public void add(int num){             synchronized(this ){                  sum = sum + num;                  System. out.println("sum = " + sum);            }      }}class Cus implements Runnable{       private Bank b = new Bank();       public void run(){             for(int x = 0; x < 3; x++){                   b.add(100);            }      }}class BankDemo{       public static void main(String[] args){            Cus c = new Cus();            Thread t1 = new Thread(c);            Thread t2 = new Thread(c);            t1.start();            t2.start();      }}

（四）、多线程下的单例设计模式
饿汉式

class Single{    private static final Single s=new Single();    private Single(){}    public static Single getInstance()    {        return s;    }}

懒汉式

class Single{    private static Single s=null;    private Single(){}    public static Single getInstance()    {        if(s==null)        {            synchronized(Single.class)            {                if(s==null)                    //---->A                    s=new Single();            }        }        return s;    }}

比较：饿汉式不存在安全问题，因为不存在多个线程共同操作数据的情况，懒汉式存在安全问题，可以使用同步函数解决， 但若直接使用同步函数，则效率较低，因为每次都需要判断，需要提前判断以提高效率。
（五）、线程间的通信–生产者和消费者

1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。
2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。
3. notifyAll()：唤醒线程池中的所有线程。
4、wait和sleep区别？
1）wait可以指定时间也可以不指定。sleep必须指定时间。
2）在同步中时，对CPU的执行权和锁的处理不同。
wait：释放执行权，释放锁。
sleep：释放执行权，不释放锁。

多生产着和多消费着问题

class Resource{       private String name ;       private int count = 1;       private boolean flag = false;       public synchronized void set(String name){            while(flag )                   try{                         this.wait();                  } catch(InterruptedException e){                        e.printStackTrace();                  }             this.name = name + count;             count++;             System.out.println(Thread.currentThread().getName() + "...生产者..." + this. name);             flag = true ;             notifyAll();      }       public synchronized void out(){             while(!flag )                   try{                         this.wait();                  } catch(InterruptedException e){                        e.printStackTrace();                  }            flag = false ;            notifyAll();            System.out.println(Thread.currentThread().getName() + "...消费者..." + this. name);      }}class Producer implements Runnable{       private Resource r ;      Producer(Resource r){             this.r = r;      }       public void run(){             while(true ){                   r.set( "馄饨");            }      }}class Consumer implements Runnable{       private Resource r ;      Consumer(Resource r){             this.r = r;      }       public void run(){             while(true ){                   r.out();            }      }}class ProducerConsumerDemo {       public static void main(String[] args){            Resource r = new Resource();            Producer pro = new Producer(r);            Consumer con = new Consumer(r);            Thread t0 = new Thread(pro);            Thread t1 = new Thread(pro);            Thread t2 = new Thread(con);            Thread t3 = new Thread(con);            t0.start();            t1.start();            t2.start();            t3.start();      }}