关键字：Thread；Runnable；synchronized；延迟加载（懒汉模式）；死锁
一、多线程 概述
1、进程：是一个正在执行中的程序。
(1)、每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
2、线程：就是进程中的一个独立的控制单元
(1)、线程控制着进程的执行。
(2)、一个进程中，至少有一个线程
3、Java VM 启动的时候会有一个进程 java.exe
(1)、该进程中至少有一个线程负责 java 程序的执行
(2)、而且这个线程运行的代码存在于 main 方法中
(3)、该线程称为主线程
4、扩展：其实更细节说明 jvm ，jvm 启动不止一个线程，还有负责垃圾回收机制的线程
二、创建线程-继承Thread类
1、一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例
(1)、定义类继承 Thread
(2)、复写 Thread 类中的 run 方法
[1]、目的：将自定义代码存储在 run 方法周中，让线程运行
(3)、调用线程的 start 方法，该方法有两个作用：启用线程，调用 run 方法
(4)、发现运行结果每次都不同，因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行
(5)、明确一点，在某一时刻，只能有一个程序在运行，(多核除外)
(6)、cpu在做着快速的切换，一道道看上去是同时运行的效果，
(7)、我们可以形象吧多线程运行行为在互相抢夺，cpu 执行权
(8)、这就是多线程的一个特性：随机性，谁抢到谁执行，至于执行多长，cpu说的算
2、例子
class ThreadDemo extends Thread{
// PrimeRun(long minPrime) {
// this.minPrime = minPrime;
// }
public void run(){
for(int x=0;x<60;x++){
System.out.println("ThreadDemo ru："+x);
}
}
}
public class Demo{
public static void main(String[] args){
ThreadDemo d = new ThreadDemo();
d.start();
for(int x=0;x<60;x++){
System.out.println("Demo run："+x);
}
}
}三、创建线程-run和start特点
1、为什么要覆盖 run 方法呢，thread 类用于描述线程
(1)、该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是 run 方法
(2)、也就是说 Thread 类中的 run 方法，用于存储线程要运行的代码
四、线程练习
1、例子
/*
创建两个线程，和主线程交替运行。
*/
class ThreadDemo extends Thread{
ThreadDemo(String name){
super(name);
}
public void run(){
for(int x=0;x<60;x++){
System.out.println(this.getName()+" Thread ："+x);
}
}
}
public class Demo{
public static void main(String[] args){
ThreadDemo d1 = new ThreadDemo("one");
ThreadDemo d2 = new ThreadDemo("two");
d1.start();
d2.start();
for(int x=0;x<60;x++){
System.out.println("main Thread："+x);
}
}
}五、线程运行状态
1、
六、获取线程对象以及名称
1、线程都有自己默认的名称：Thread-编号 ，该编号从0开始
2、currentThread()：返回对当前正在执行的线程对象的引用。
3、getName()：获取线程名称
4、setName() 或者 构造函数：设置线程的名称
七、售票的例子
/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket extends Thread{
private static int tick = 100;
public void run(){
while(true){
if(tick>0){
System.out.println(Thread.currentThread().getName()+" sale："+tick--);
}
}
}
}
public class Demo{
public static void main(String[] args){
Ticket t1 = new Ticket();
Ticket t2 = new Ticket();
Ticket t3 = new Ticket();
Ticket t4 = new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}八、创建线程-实现Runnable接口 1、创建线程的第二种方式：实现 Runable 接口
(1)、定义类实现 Runnable接口
(2)、覆盖 Runnable 接口中的 run 方法,将线程要运行的代码存放在该 run 方法中
(3)、通过 Thread 类建立线程对象
(4)、将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造函数
[1]、为什么要将 Runnable 接口的子类对象传递给 Thread 的构造函数，因为自定义的 run 方法所属的对象是 Runnable 接口的子类对象，所以要让线程去指定对象的 run 方法
(5)、调用 Thread 类的 start 方法开启线程并调用 Runnable 接口子类的 run 方法
/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket implements Runnable{
private int tick = 100;
public void run(){
while(true){
if(tick>0){
System.out.println(Thread.currentThread().getName()+" sale："+tick--);
}
}
}
}
public class Demo{
public static void main(String[] args){
Ticket t = new Ticket();
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
t0.start();
t1.start();
t2.start();
t3.start();
}
}2、实现方式和继承方式有什么区别
(1)、实现方式好处：避免了单继承的局限性
(2)、在定义线程时：建议使用实现方式
(3)、两种方式区别：
[1]、继承 Thread：线程代码存放在 Thread 子类 run 方法中
[2]、实现 Runnable：线程代码存放在接口的子类的 run 方法中
九、多线程的安全问题
1、对多条操作共享数据的语句，只能让一个线程都执行完，再执行过程中，不可以参与执行。
2、java对于多线程的安全，提供了专业解决方式：
(1)、就是同步代码块
(2)、synchronized(){}
3、
/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket implements Runnable{
private int tick = 10000;
Object obj = new Object();
public void run(){
while(true){
synchronized(obj){
if(tick>0){
System.out.println(Thread.currentThread().getName()+" sale："+tick--);
}
}
}
}
}
public class Demo{
public static void main(String[] args){
Ticket t = new Ticket();
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
t0.start();
t1.start();
t2.start();
t3.start();
}
}十、多线程同步代码块 1、对象如同锁，持有所得线程可以在同步中执行。
2、没有持有锁的线程即使获取 cpu 的执行权，也进不去，因为没有获取锁
3、火车上的卫生间—-经典
4、同步的前提
(1)、必须要有两个或者两个以上的线程
(2)、必须是多个线程使用同一个锁
(3)、必须保证同步过程中必须有一个线程在运行
5、弊端
(1)、多个线程需要判断锁，较为消耗资源
十一、多线程-同步函数
1、synchronized 作为修饰符号，放在函数上
/*
需求：银行有一个金库
有两个储户分别存300元，每次存100，存3次
目的：改程序，是否有安全问题
如何找问题：
1、明确哪些代码是多线程运行代码
2、明确共享数据
3、明确多线程运行代码中哪些语句是操作共享数据的
*/
class Bank{
private int sum;
Object obj = new Object();
public synchronized void add(int n){
sum = sum + n;
System.out.println("sunm = "+sum);
}
}
class Cus implements Runnable{
private Bank b = new Bank();
public void run(){
for(int x=0;x<3;x++){
b.add(100);
}
}
}
public class Demo{
public static void main(String[] args){
Cus c = new Cus();
Thread c0 = new Thread(c);
Thread c1 = new Thread(c);
c0.start();
c1.start();
}
}十二、多线程-同步函数的锁是this
1、同步函数用的是哪一个锁呢？
2、函数需要被对象调用。那么函数都有一个所属对象引用。就是this
3、所以同步函数使用的所是this
十三、多线程-静态同步函数的锁是Class对象
1、如果同步函数被静态修饰后，使用的锁是什么呢？
2、通过验证，发现不再是 this ，因为静态方法中也不可以定义 this
3、静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象，
4、类名.class 该对象的类型是Class
5、静态的同步方法，使用的锁是该方法所在类的字节码文件对象 类名.class
十四、多线程-单例设计模式-懒汉式
1、对象延迟加载
2、多线程会有问题，使用同步锁，该类所在对象
public static Single getInstance(){
if(s==null){
synchronized(Single.class){
if(s==null){
s = new Single();
}
}
}
return s;
}十五、多线程-死锁
1、同步中嵌套同步
/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket implements Runnable{
private static int tick = 1000;
Object obj = new Object();
static boolean flag = true;
public void run(){
if(flag){
while(true){
synchronized(obj){
show();
}
}
}else{
while(true){
show();
}
}
}
public static synchronized void show(){
flag = true;
synchronized(obj){
if(tick>0){
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+" show："+tick--);
}
}
}
}
public class Demo{
public static void main(String[] args){
Ticket t = new Ticket();
Thread t0 = new Thread(t);
Thread t1 = new Thread(t);
t0.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t1.start();
}
}