今天完成的事情：

并行：指两个或多个事件在同一时刻发生（同时执行）。

并发：指两个或多个事件同一时间段内发生（交替执行）。

功能到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：

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方法，必须在同步中使用