进程 process 线程 Thread
main称之为主线程，为系统的入口，用于执行整个程序
线程创建的三种方式：
- 继承Thread类
- 实现Runnable接口
- 实现Callable接口
继承Thread类：
public class Test extends Thread { @Override public void run() { //run 方法线程体 for (int i = 0; i < 20; i++) { System.out.println(i); } } public static void main(String[] args) { //创建一个线程对象 Test t=new Test(); //开启线程 t.start(); //知道跟run方法的区别 //main线程 主线程 for (int i = 0; i < 2000; i++) { System.out.println("main方法"+i); } } }
分析调用start跟run方法的区别：
调用start方法主线程跟子线程会并行交替执行。 run方法主线程会先执行完之后再执行子线程。
总结：注意，线程开启不一定立即执行，是由cpu调度的。
实现Runnable接口：
实现该接口，重写run方法，执行线程需要丢入runnable接口实现类。调用start方法
public class Test implements Runnable { @Override public void run() { //run 方法线程体 for (int i = 0; i < 20; i++) { System.out.println(i); } } public static void main(String[] args) { //创建Runnable接口的实现类对象 Test t=new Test(); //创建线程对象，通过线程对象来开启我们的线程，代理 Thread t1=new Thread(t); t1.start(); //main线程 主线程 for (int i = 0; i < 2000; i++) { System.out.println("main方法"+i); } } }
推荐使用Runnable接口实现多线程
小结：
关于线程的不安全性示例代码：
public class Test implements Runnable { private int ticketNum=10; @Override public void run() { while(true){ if (ticketNum<=0){break;} try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } //run 方法线程体 System.out.println(Thread.currentThread().getName()+"拿到了第"+ticketNum--+"张票"); } } public static void main(String[] args) { //创建Runnable接口的实现类对象 Test t=new Test(); //创建线程对象，通过线程对象来开启我们的线程，代理 new Thread(t,"小红").start(); new Thread(t,"小明").start(); new Thread(t,"小张").start(); } }
输出结果为：
此时可以看到 同一张票被两个不同的人抢到，此时就表明存在线程安全问题。当多个线程操作一个对象的时候会出现线程安全问题。
继续看以下龟兔赛跑代码示例：
public class Test3 implements Runnable{ private String winner; @Override public void run() { for (int i = 0; i < 101; i++) { //模拟兔子休息 if (Thread.currentThread().getName().equals("兔子")&&i%10==0){ try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } if (GameOver(i)){ break; } System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步"); } } //判断比赛是否结束 private Boolean GameOver(int step){ if (winner!=null){ return true; }else { if (step>=100){ winner=Thread.currentThread().getName(); System.out.println("胜利者是---->"+winner); } } return false; } public static void main(String[] args) { Test3 t=new Test3(); new Thread(t,"乌龟").start(); new Thread(t,"兔子").start(); } }
当线程为兔子时模拟兔子睡觉，即Thread.sleep()。胜利者一定是乌龟。
实现Callable接口：
---------------------------------------------------------------------------------------
扩展知识：
关于静态代理：
静态代理模式总结：真实对象跟代理对象都要实现同一个接口，代理对象要代理真实角色。
好处：代理对象可以在做很多真实对象无法实现的事情，真实对象可以专注自己可以做的事。
Thread类的底层实现原理就是使用静态代理类。
函数式接口：
- 任何接口只包含唯一一个抽象方法，那么它就是一个函数式接口。
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。
-----------------------------------------------------------------------------------------
线程状态：
线程方法：
停止线程：
线程礼让：yield 方法。因为线程执行由cpu调度，所以礼让不一定成功，看cpu心情。
线程插队：join 方法。即两个线程在执行的时候，本来主线程会先执行完毕再执行子线程，但是此刻我设定一个条件当主线程执行到某一步的时候
我使用join方法，此时主线程会进行等待，等子线程执行完毕之后才会继续执行。
关于线程的状态有以下几种;
线程优先级：
线程分为 用户线程 守护线程
关于线程锁：
每个对象都有一把锁
重点：synchronized
1. 同步方法，锁的是This。上面抢票示例代码会出现线程安全问题，当我们在“抢票”的方法上使用 synchronized 时，表示该方法
在执行时会被上锁，只有该方法执行完之后，锁会被释放，后续对象才可以拿到该锁进行处理。Buy()方法上使用锁代表锁的是BuyTicket对象。
2 . 同步块
示例代码：
public class Test2 { public static void main(String[] args) throws InterruptedException { List<String> arrList=new ArrayList<>(); for (int i = 0; i < 10000; i++) { new Thread(( )->{ arrList.add(Thread.currentThread().getName()); }).start(); } Thread.sleep(2000); System.out.println(arrList.stream().count()); } }
结果：
从输出结果可看出并未讲10000个线程对象添加到集合中，原因是 两个线程在同一时间将同一个对象添加到了同一个内存位置，因此集合中的对象会出现覆盖的情况，所以产生了此种情况。
处理方法：
public class Test2 { public static void main(String[] args) throws InterruptedException { List<String> arrList=new ArrayList<>(); for (int i = 0; i < 10000; i++) { new Thread(( )->{ synchronized(arrList){ arrList.add(Thread.currentThread().getName()); } }).start(); } Thread.sleep(2000); System.out.println(arrList.stream().count()); } }
将“arrList”对象添加锁，同步代码块。
JUC：CopyOnWriteArrayList 此集合为一个线程安全的集合，与arrayList集合不同。是java.util.concurrent包下的
关于死锁：
不要在一个锁还未被释放的时候就想着去取另一个锁，这种情况就容易造成死锁的产生。即在“synchronized”代码块中嵌套"synhronized"
Lock锁：
Lock锁与synchronized对比：
生产消费者模型：
1.管程法 (生产者，消费者，产品，缓冲区)
public class Test3 { public static void main(String[] args) { SynContainer synContainer=new SynContainer(); new Productor(synContainer).start(); new Customer(synContainer).start(); } } //生产者 class Productor extends Thread{ SynContainer synContainer; public Productor(SynContainer synContainer){ this.synContainer=synContainer; } @Override public void run() { //生产100只鸡仔 for (int i = 1; i < 100; i++) { try { synContainer.push(new Chicken(i)); System.out.println("生产了---->"+i+"只鸡仔"); } catch (InterruptedException e) { e.printStackTrace(); } } } } //消费者 class Customer extends Thread{ SynContainer synContainer; public Customer(SynContainer synContainer){ this.synContainer=synContainer; } @Override public void run() { //消费100只鸡仔 for (int i = 1; i < 100; i++) { try { System.out.println("消费了"+synContainer.Consumer().id+"鸡仔"); } catch (InterruptedException e) { e.printStackTrace(); } } } } //产品 class Chicken{ int id; public Chicken(int id) { this.id = id; } } //缓冲区 class SynContainer{ //定义一个缓冲区的大小 Chicken[] chickens=new Chicken[10]; //定义鸡的个数 int count=0; //生产鸡仔 public synchronized void push(Chicken chicken) throws InterruptedException { //当生产的鸡仔达到容量时 if (count== chickens.length){ //此时应该暂停生产 this.wait(); } //如果没有满 我们需要丢入鸡仔 chickens[count]=chicken; count++; //通知消费者可以开始消费 this.notifyAll(); } //消费鸡仔 public synchronized Chicken Consumer() throws InterruptedException { //当没有鸡仔可以消费时 if (count==0){ //此时消费者应该处于等待，等待生产者继续生产 this.wait(); } //否则鸡仔将被消费 count--; Chicken chicken = chickens[count]; //并告知生产者鸡仔已经被消费 this.notifyAll(); return chicken; } }
线程池：
