线程，同步（总结）

                              #**线程**

拓展：
并行：指两个或多个事件在同一时刻发生（同时执行）。
并发：指两个或多个事件同一时间段内发生（交替执行）。
功能到Cpu的通道就是线程
Cpu在短暂的时间内（很短的时间段）内只能运行一个线程，只不过CPU是在多线程之间做高速的切换，多块，比人的感觉快（比如：360）
Cpu调度：
分时调度：线程在Cpu上的运行时间一样
抢占式调度：哪个线程优先级高，Cpu优先执行哪个线程，如果多个线程优先级一样，那么会随机一个执行。（java就是抢占式）
主线程：main方法，专门为main方法服务
单线程：前面的代码执行不完，后面的执行不了
创建线程的方式：java.util.Thread
1，定义一个类，继承Thread类
2，重写Thread中的run方法
3，创建线程类对象，调用start方法开启线程
注意：
调用start方法，开启新的线程，并执行run方法
调用run方法，只是简单的调用方法而已，不会开启新线程
思考：Thread是线程类，为什么还要创建子类对象，并开启线程呢？
直接创建对象，开启线程，肯定没有问题，但是Thread类中的run方法指定的线程任务，不是我们想要的，所以定义子类继承Thread，覆盖重写run方法，指定我们自己的线程任务
多线程的运行原理
1，执行线程任务的run方法，是线程私有的
2，某个线程任务，出现异常，不会影响其他线程的执行
Thread类获取线程名字的方法
1，Thread类的成员方法
public String getName():获取线程名字
2，Thread类的静态方法
public static Thread currentThread（）：返回当前正在执行的线程对象
public static void sleep（long millis）：在指定的毫秒数内让正在执行的线程休眠（暂定执行）
创建并开启线程的方式二
步骤：
1，定义Runnable接口的实现类
2，实现类覆盖重写run方法，指定线程任务
3，创建Runnable接口的实现类对象
4，创建Thread类的对象，传递Runnable接口的实现类对象
5，Thread类的对象调用start方法，开启线程
思考：
既然可以创建Thread子类对象，开启线程，为什么还要实现Runnable接口的方式呢？
解答：
好处是<1>避免了java中类的单继承的局限性<2>降低了线程任务对象和线程对象之间的耦合性（事务之间的关系）
匿名内部类的方式创建线程：
1，作用：
创建子类对象的快捷方式
创建实现类的快捷方式
2，格式：
new 父类/接口（）{
覆盖重写抽象方法；
}

                              #**同步**

多线程访问共享数据，出现错误数据。不允许，必须解决
解决方案：使用同步技术
同步代码块1：
1，作用：解决线程安全问题
2，格式：
synchronized(任意对象){
…
}
3,注意：
<1>{}:所有操作共享数据的代码，都要写在{}中
<2>任意对象：对象锁，锁对象，专业术语：对象监视器
<3>锁对象可以是任意对象，必须保证唯一
同步代码块2：
格式：修饰符 synchronized 返回值类型 方法名称（参数列表）{
…
}
注意：
<1>{}：所有操作共享数据的代码，都要写在{}中
<2>同步方法，是否具有锁对象？
必须有：this代表调用的方法的对象
使用Lock接口解决线程安全问题
java.util.concurrent.locks.Lock接口
抽象方法：
—public abstract void lock():获取锁
—public abstract void unlock():释放锁
实现类：
java.util.concurrent.locks.ReentrantLock类
空参构造：public ReentrantLock（）
关于wait()方法和notify()方法
java.lang.Object类
方法
public void wait():释放锁对象，进入无限等待，在其他线程调用此对象的notify()方法前，导致当前线程等待
public void notify():唤醒在此对象监视器（锁对象）上等待的单个线程
锁对象a.wait():进入无限等待，是释放了锁对象a
锁对象a.notify():唤醒的是等待锁对象a的线程
注意：
1，Object类定义wait和notify方法
2，任意对象都可以调用wait和notify方法
3，锁对象可以是任意对象
4，但是锁对象必须使用在同步中，所以wait和notify方法，必须在同步中使用