/*
进程：正在执行中的程序（直译）

线程：就是进程中一个负责程序执行的控制单元（执行路径）
一个进程中 可以多执行路径，称之为多线程。

一个进程中至少要有一个线程。

开启多个线程是为了同时运行多部分代码

每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。


其实应用程序的执行都是在CPU在做着快速的切换完成的。这个切换是随机的。

IVM启动时就启动了多个线程，至少有两个线程可以分析的出来。

1，执行main函数的线程，
        该线程的任务代码都定义在main函数中。

2，负责垃圾回收的线程。


*/

/*
如何创建一个线程呢？
创建线程方式一：继承Thread类。
步骤：
1，定义一个类继承Thread类。
2，覆盖Thread类中的run方法。
3，直接创建Thread类的子类对象创建线程。
4，调用start方法开启线程并调用线程的任务run方法执行。

创建线程的目的是为了开启一条执行路径，1去运行指定的代码和其他代码实现同时执行。
而运行的指定代码就是这个执行路径的任务。
jvm创建的主线程的任务都定义在了主函数中。

而自定义的线程它的任务在哪儿呢？
Thread类用于描述线程，线程是需要任务的。所以Thread类也对任务的描述。
这个任务就通过Thread类中的run方法来体现。也就是说，run方法就是封装自定义线程运行任务的函数。

run方法中定义就是线程要运行的任务代码。

开启线程是为了运行指定代码，所以只有继承Thread类，并复写run方法。
将运行的代码定义在run方法中即可。

可以通过Thread的getName获取线程的名称Thread-编号（从0开始）
主线程的名字就是main。
*/
/*
CPU的执行资格：可以被CPU的处理，在处理队列中排队
CPU的执行权：正在被CPU的处理

*/
/*
创建线程的第一种方式：继承Thread类。

创建线程的第二种方式：实现Runnable接口。

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



实现Runnable接口的好处：
1，将线程的任务从线程的子类中分离出来，进行了单独的封装。
        按照面向对象的思想将任务封装成对象。
2，避免了java单继承的局限性。

所以创建线程的第二种方法较为常用。


*/
/*
线程安全问题产生的原因：

1，多个线程在操作共享的数据。
2，操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。
就会导致线程安全问题的产生。

解决思路：
就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，
其他线程不可以参与运算的。
必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

在java中，用同步代码块就可以解决这个问题。

同步代码块的格式：
synchronized(对象)
{
        需要同步的代码；
}

同步的好处：解决了线程的安全问题.

同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。



*/
/*
同步函数使用的锁是this;

同步函数和同步代码块的区别：
同步函数的锁是固定的this。

同步代码块的锁是任意的对象。

建议使用同步代码块。

*/
/*
静态的同步函数使用的锁是 ：该函数所属字节码文件对象
可以用 getClass方法获取 ，也可以用当前  类名.class 表示。
*/

/*
等待/唤醒机制。

设计的方法：

1.wait():让线程处于冻结状态，被wait的线程会被存储到线程池中。
2.notify():唤醒线程池中一个线程（任意）。
3.notifyAll():唤醒线程池中的所有线程。

这些方法都必须定义在同步中。
因为这些方法是用于操作线程状态的方法。
必须要明确到底操作的是哪个锁上的线程。


为什么操作线程的方法wait  notify  notifyAll 定义在了Object类中？

因为这些方法是监视器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中。


*/
/*
生产者，消费者。

多生产者，多消费者

if判断标记，只有一次，会导致不该运行的线程运行了，出现了数据错误的情况。
while判断标记，解决了线程获取执行权后，是否要运行！

notify:只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致死锁。
notifyAll解决了本方线程一定会唤醒对方线程的问题。
*/
/*
jdk1.5以后将同步和锁封装成了对象。
并将操作锁的隐式方法定义到了该对象中，
将隐式动作变成了显示动作。

Lock接口：出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实的锁操作。
同时更为灵活，可以一个锁上加上多组监视器。
lock()：获取锁。
unlock()：释放锁，通常需要定义finally代码块中。

Condition接口：出现替代了Object中的wait notify notifyAll方法。
                将这些监视器方法单独进行了封装，变成Codition监视器对象。
                可以任意锁进项组合。

await();
signal();
signalAll();


*/
/*

wait和sleep的区别？

1，wait可以指定时间也可以不指定。
        sleep必须指定时间。

2，在同步中时，对CPU的执行权和锁的处理不同。
        wait：释放执行权，释放锁
        sleep：释放执行权，不释放锁。

*/

/*
停止线程：
1，stop方法。

2，run方法结束。

怎么控制线程的任务结束呢?
任务中都会有循环结构，只要控制住循环就可以结束任务。

控制循环通常就用定义标记来完成。

但是如果线程处于了冻结状态，无法读取标记，如何结束呢？

可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CPU的执行资格。

但是强制动作会放生看InterruptedException，记得要处理.

*/

/*
进程：正在执行中的程序（直译）

线程：就是进程中一个负责程序执行的控制单元（执行路径）
一个进程中 可以多执行路径，称之为多线程。

一个进程中至少要有一个线程。

开启多个线程是为了同时运行多部分代码

每一个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。


其实应用程序的执行都是在CPU在做着快速的切换完成的。这个切换是随机的。

IVM启动时就启动了多个线程，至少有两个线程可以分析的出来。

1，执行main函数的线程，
        该线程的任务代码都定义在main函数中。

2，负责垃圾回收的线程。


*/

/*
如何创建一个线程呢？
创建线程方式一：继承Thread类。
步骤：
1，定义一个类继承Thread类。
2，覆盖Thread类中的run方法。
3，直接创建Thread类的子类对象创建线程。
4，调用start方法开启线程并调用线程的任务run方法执行。

创建线程的目的是为了开启一条执行路径，1去运行指定的代码和其他代码实现同时执行。
而运行的指定代码就是这个执行路径的任务。
jvm创建的主线程的任务都定义在了主函数中。

而自定义的线程它的任务在哪儿呢？
Thread类用于描述线程，线程是需要任务的。所以Thread类也对任务的描述。
这个任务就通过Thread类中的run方法来体现。也就是说，run方法就是封装自定义线程运行任务的函数。

run方法中定义就是线程要运行的任务代码。

开启线程是为了运行指定代码，所以只有继承Thread类，并复写run方法。
将运行的代码定义在run方法中即可。

可以通过Thread的getName获取线程的名称Thread-编号（从0开始）
主线程的名字就是main。
*/
/*
CPU的执行资格：可以被CPU的处理，在处理队列中排队
CPU的执行权：正在被CPU的处理

*/
/*
创建线程的第一种方式：继承Thread类。

创建线程的第二种方式：实现Runnable接口。

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



实现Runnable接口的好处：
1，将线程的任务从线程的子类中分离出来，进行了单独的封装。
        按照面向对象的思想将任务封装成对象。
2，避免了java单继承的局限性。

所以创建线程的第二种方法较为常用。


*/
/*
线程安全问题产生的原因：

1，多个线程在操作共享的数据。
2，操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。
就会导致线程安全问题的产生。

解决思路：
就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，
其他线程不可以参与运算的。
必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

在java中，用同步代码块就可以解决这个问题。

同步代码块的格式：
synchronized(对象)
{
        需要同步的代码；
}

同步的好处：解决了线程的安全问题.

同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。



*/
/*
同步函数使用的锁是this;

同步函数和同步代码块的区别：
同步函数的锁是固定的this。

同步代码块的锁是任意的对象。

建议使用同步代码块。

*/
/*
静态的同步函数使用的锁是 ：该函数所属字节码文件对象
可以用 getClass方法获取 ，也可以用当前  类名.class 表示。
*/

/*
等待/唤醒机制。

设计的方法：

1.wait():让线程处于冻结状态，被wait的线程会被存储到线程池中。
2.notify():唤醒线程池中一个线程（任意）。
3.notifyAll():唤醒线程池中的所有线程。

这些方法都必须定义在同步中。
因为这些方法是用于操作线程状态的方法。
必须要明确到底操作的是哪个锁上的线程。


为什么操作线程的方法wait  notify  notifyAll 定义在了Object类中？

因为这些方法是监视器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定定义在Object类中。


*/
/*
生产者，消费者。

多生产者，多消费者

if判断标记，只有一次，会导致不该运行的线程运行了，出现了数据错误的情况。
while判断标记，解决了线程获取执行权后，是否要运行！

notify:只能唤醒一个线程，如果本方唤醒了本方，没有意义。而且while判断标记+notify会导致死锁。
notifyAll解决了本方线程一定会唤醒对方线程的问题。
*/
/*
jdk1.5以后将同步和锁封装成了对象。
并将操作锁的隐式方法定义到了该对象中，
将隐式动作变成了显示动作。

Lock接口：出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实的锁操作。
同时更为灵活，可以一个锁上加上多组监视器。
lock()：获取锁。
unlock()：释放锁，通常需要定义finally代码块中。

Condition接口：出现替代了Object中的wait notify notifyAll方法。
                将这些监视器方法单独进行了封装，变成Codition监视器对象。
                可以任意锁进项组合。

await();
signal();
signalAll();


*/
/*

wait和sleep的区别？

1，wait可以指定时间也可以不指定。
        sleep必须指定时间。

2，在同步中时，对CPU的执行权和锁的处理不同。
        wait：释放执行权，释放锁
        sleep：释放执行权，不释放锁。

*/

/*
停止线程：
1，stop方法。

2，run方法结束。

怎么控制线程的任务结束呢?
任务中都会有循环结构，只要控制住循环就可以结束任务。

控制循环通常就用定义标记来完成。

但是如果线程处于了冻结状态，无法读取标记，如何结束呢？

可以使用interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CPU的执行资格。

但是强制动作会放生看InterruptedException，记得要处理.

*/