多线程

（一）、进程、线程、多进程的概念
进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。
注意点：
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();
      }
}