多线程

并行：指两个和多个时间在同一时刻发生。

并发：指两个或多个时间在同一时间段内发生。

在操作系统中，在很多道程序环境下，并发性指在同一时间段内有多个程序在同时运行，但在单CPU操作系统下，每一时刻只能有一道程序执行（时间片：CPU分配给各个程序的时间），故这些程序只能是分时的交替进行（但是速度很快，把1秒钟分成1万个时间片）而不是我们以为的同时在运行多个程序。
倘若计算机系统有多个CPU，则这些可以并发执行的程序被分配到多个处理器上，实现多任务并行操作，因为是微观的，所以大家在使用电脑时感觉是多个程序同时执行的。
从宏观角度理解线程是并行运行的，微观角度看的话是串行运行的，
当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程的调度。

线程和进程的区别：

进程：有独立的内存空间，进程中的数据存放空间（堆空间和栈空间），是独立的，至少有一个线程
线程：栈空间是独立的，堆空间是共享的，线程消耗的资源比进程小。
线程先后执行的顺序是由CPU（JVM）调度的，进程的执行是由CPU控制的。
在一个java程序中，至少包含两个线程,main线程，垃圾回收线程（后台线程，用来不定时的回收垃圾，不能说等主方法运行完了再回收，是随机不定时动态回收的）

创建线程

a.继承Thread类
b.实现Runnable接口（当用这种方法时，只是实现了这个接口，它并不是线程类，没有start方法，所以要创建线程的对象）
线程类：Thread和其子类才叫做线程类
启动线程时不要调用run方法，而是调用start方法。如果调用run方法只是单纯的用对象调用了一次方法，而并没有启动线程，程序还只是一个线程。

继承方式和实现方式的区别：

继承方式：从多线程共享资源上分析，继承方式不能做到3个同学吃150个苹果
实现方式：共享同一个资源，3个同学吃了50个苹果

线程不安全

解决
1.同步代码块
synchronized（this：当前对象的锁）{需要通同步的代码块}
2.同步方法
3.锁机制
Lock是接口，创建其实现类的对象： final Lock lock=new ReentranLock()
两个方法：
lock.lock
lock.unlock

synchronized的好与坏

安全但是性能低
建议：较少它所包含的代码块

面试题

StringBuffer与StringBuilder区别：
StringBuffer用synchronized修饰，安全，性能不高
StringBuilder不用synchronized修饰，不安全，性能高
ArrayList和vector（前身，安全，性能差）
Hashmap和Hashtable（前身，安全，性能差）

wait()和notify()

等待与唤醒：可以让多个线程有序的逐条工作
wait使其下面的代码阻塞并且释放锁
wait和notify必须在同步synchronized中使用

---

经典的消费者案例

//共享资源案例
public class shareSource {
    private String name;
    private String sex;
    boolean isNull=true;
    //添加数据
    public synchronized void add(String name,String sex) throws InterruptedException {
        if(!isNull)
        {
          wait();
        }
        this.name=name;
        Thread.sleep(10);
        this.sex=sex;
        isNull=false;
        notify();
    }

    //输出数据
    public synchronized void print() throws InterruptedException {
        if(isNull)
        {
            wait();
        }
        System.out.println(name+"---"+sex);
        isNull=true;
        notify();
    }
}
//消费者
public class consumer implements Runnable{
   shareSource s=null;

    public consumer(shareSource s) {
        this.s = s;
    }

    @Override
    public void run() {
        for(int i=0;i<500;i++)
        {
            try {
                s.print();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
            }

//生产者
public class producer implements Runnable{
    shareSource s=null;

    public producer(shareSource s) {
        this.s = s;
    }

    @Override
    public void run() {
        for(int i=0;i<50;i++)
        {
            if(i%2==0)
            {
                try {
                    s.add("李兵","男");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            else{

                try {
                    s.add("赵莹","女");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            }
        }

    }
//测试类
public class testThread {
    public static void main(String[] args) {
        shareSource s=new shareSource();
        producer pp=new producer(s);
        Thread  p=new Thread(pp);
        consumer cc=new consumer(s);
        Thread c=new Thread(cc);
        p.start();
        c.start();

    }
}