不建议使用：避免oop单继承局限性
主要分为三步： 线程不一定立即执行，等待cpu安排调度
自定义线程类继承Thread类重写run()方法，编写线程执行体创建线程对象，调用start()方法启动线程 public class TestThread1 extends Thread{ @Override public void run() { //run方法线程体 for(int i=0;i<100;i++){ System.out.println("我在看代码----"+i); } } public static void main(String[] args) { //主线程 //创建一个线程对象 TestThread1 testThread1 = new TestThread1(); testThread1.start(); for(int i=0;i<100;i++){ System.out.println("我在学习多线程----"+i); } } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sK1C1LXD-1602064491112)(C:\Users\Administrator\Pictures\Camera Roll\5.png)]
推荐使用：灵活方便，方便同一个对象呗多个线程使用
自定义线程类实现Runnable接口重写run()方法，编写线程执行体创建线程对象，调用start()方法启动线程 public class TestThread2 implements Runnable{ @Override public void run() { //run方法线程体 for(int i=0;i<200;i++){ System.out.println("我在看代码----"+i); } } public static void main(String[] args) { //主线程 //创建一个线程对象 TestThread2 testThread2 = new TestThread2(); new Thread(testThread2).start(); for(int i=0;i<200;i++){ System.out.println("我在学习多线程----"+i); } } }（了解即可）
实现Callable接口，需要返回值类型重写call方法，需要抛出异常创建目标对象创建执行服务：ExecutorService ser=Executors.newFixedThreadPool(线程数量);提交执行：Future result1=ser.submit(线程对象);获取结果：boolean r1=result1.get();关闭服务：ser.shutdownNow();好处：可以定义返回值、可以抛出异常
(sleep放大问题的发生性)
sleep指定当前线程阻塞的毫秒数sleep存在InterruptedExecption异常sleep时间到达后线程进入就绪状态sleep可以模拟网络延时、倒计时等每个对象都有一个锁，sleep不会释放锁 import java.text.SimpleDateFormat; import java.util.Date; public class TestSleep { public static void main(String[] args) { Date date = new Date(System.currentTimeMillis()); while (true){ try { Thread.sleep(1000); System.out.println(new SimpleDateFormat("HH:mm:ss").format(date)); date=new Date(System.currentTimeMillis()); } catch (InterruptedException e) { e.printStackTrace(); } } } public static void tenDown() throws InterruptedException { int num=10; while (true){ Thread.sleep(1000); System.out.println(num--); if(num<=0) { break; } } } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s4TOHEsf-1602064491120)(C:\Users\Administrator\Pictures\Camera Roll\8.png)]
join合并线程，待此线程执行完成后，再执行其他线程，其他此线程阻塞。 可以想象成插队
public class TestJoin implements Runnable{ public static void main(String[] args) { Thread thread = new Thread(new TestJoin()); thread.start(); for(int i=0;i<50;i++){ if(i==20){ try { thread.join(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("普通"+i); } } @Override public void run() { for(int i=0;i<100;i++){ System.out.println("Vip"+i); } } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RhbOZgi8-1602064491121)(C:\Users\Administrator\Pictures\Camera Roll\7.png)]
一个线程可以在给定时间点处于一个状态，这些状态是不反映任何操作系统线程状态的虚拟机状态
线程状态有以下几种： 使用 Thread.state
new：尚未启动的线程处于此状态runnable：在虚拟机中执行的线程处于此状态blocked：被阻塞等待监视器锁定的线程处于此状态waiting：正在等待另一个线程执行特定动作的的线程处于此状态time_waiting：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态terminated：已退出的线程处于此状态 public class TestState { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(()->{ for(int i=0;i<5;i++){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("/"); }); //观察开始状态 Thread.State state=thread.getState(); System.out.println(state); //观察启动状态 thread.start(); state=thread.getState(); System.out.println(state); while (state!=Thread.State.TERMINATED){//只要线程不终止，一直输出状态 Thread.sleep(1000); state=thread.getState();//更新线程状态 System.out.println(state); } } }java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定调度
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这还要看cpu的调度
线程的优先级用数字表示，范围从1-10
主线程默认优先级为5
先设置优先级再启动
设置优先级和获取优先级使用setPriority（int xxx）和getPriority（）
public class TestPriority { public static void main(String[] args) { System.out.println(Thread.currentThread().getName()+"=>"+Thread.currentThread().getPriority()); MyPriority myPriority = new MyPriority(); Thread t1 = new Thread(myPriority); Thread t2 = new Thread(myPriority); Thread t3 = new Thread(myPriority); Thread t4= new Thread(myPriority); Thread t5 = new Thread(myPriority); t1.start(); t2.setPriority(6); t2.start(); t3.setPriority(10); t3.start(); t4.setPriority(4); t4.start(); t5.setPriority(8); t5.start(); } } class MyPriority implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()+"=>"+Thread.currentThread().getPriority()); } }使用抢票为例：出现多个线程抢到同一张票和负票的问题
public class BuyTicket implements Runnable { private int num=10; boolean flag=true; @Override public void run() { while (flag){ try { buy(); } catch (InterruptedException e) { e.printStackTrace(); } } } private synchronized void buy() throws InterruptedException { if(num<=0){ flag=false; return; } Thread.sleep(100); System.out.println(Thread.currentThread().getName()+"拿到了第"+num--+"票"); } public static void main(String[] args) { TestThread3 testThread3 = new TestThread3(); new Thread(testThread3,"老师").start(); new Thread(testThread3,"小明").start(); new Thread(testThread3,"黄牛").start(); } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cjy7bIAK-1602064491126)(C:\Users\Administrator\Pictures\Camera Roll\6.png)]
银行取钱
如果两个人同时取一张银行卡里的钱就会出现
public class UnSafeBank { public static void main(String[] args) { Account account=new Account(100,"A"); Drawing you =new Drawing(account,50,"B"); Drawing yourFirend=new Drawing(account,100,"C"); you.start(); yourFirend.start(); } } //账户 class Account{ double money; String name; public Account(double money, String name) { this.money = money; this.name = name; } } //银行 class Drawing extends Thread{ Account account;//账户 double drawingMoney;//取的钱 double nowMoney;//现在手里的钱 @Override public void run() { if(account.money-drawingMoney<0){ System.out.println(Thread.currentThread().getName()+"钱不够，取不了"); return; } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } account.money=account.money-drawingMoney; nowMoney=nowMoney+drawingMoney; System.out.println(account.name+"余额为："+account.money); System.out.println(this.getName()+"手里的钱："+nowMoney);//=Thread.currentThread().getName(); } public Drawing(Account account, double drawingMoney, String name){ this.account=account; this.drawingMoney=drawingMoney; } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UFpK9dsy-1602064491127)(C:\Users\Administrator\Pictures\Camera Roll\9.png)]
集合问题
使用多个线程同时操作一个集合出现数量不匹配问题
public class UnSafeList { public static void main(String[] args) { List<String> list=new ArrayList<String>(); for(int i=0;i<100000;i++){ new Thread(()-> list.add(Thread.currentThread().getName())).start(); } try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-albPsvzG-1602064491128)(C:\Users\Administrator\Pictures\Camera Roll\10.png)]
由于我们可以通过private关键字来保证数据对象只等被方法访问，我们也能使用synchronized关键字针对方法
同步方法：
public synchronized void method(int args){}synchronized方法控制对“对象”的访问，每一个对象对应一把锁，每个synchronized方法都必须获得调用改方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
**缺陷：**若将一个大的方法申明为synchronized将会影响效率
方法里面需要修改的内容才需要锁，锁的太多浪费资源synchronized默认锁的是this[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uGdsC9nk-1602064491129)(C:\Users\Administrator\Pictures\Camera Roll\11.png)]
同步块：
锁的对象就是变化的量，需要增删改的对象
synchronized(Obj){}Obj称之为***同步监视器***，可以是任何对象，但是推荐使用共享资源作为同步监视器
同步监视器的执行过程：
第一线程访问，锁定同步监视器，执行其中代码第二线程访问，发现同步监视器被锁定，无法访问第一线程访问完毕，解锁同步监视器第二线程访问，发现同步监视器没有锁，然后锁定并访问[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cmqoYvDe-1602064491129)(C:\Users\Administrator\Pictures\Camera Roll\12.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tgvzj40K-1602064491130)(C:\Users\Administrator\Pictures\Camera Roll\13.png)]
list还能使用CopyOnWriteArrayList实现安全集合
public class TestSafeList { public static void main(String[] args) { CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>(); for(int i=0;i<100000;i++){ new Thread(()->{ list.add(Thread.currentThread().getName()); }).start(); } try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(list.size()); } }多个线程各自占用一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情形
死锁避免的方法：
互斥条件：一个资源每次只能被一个进程使用请求与保持条件：一个进程因请求资源而阻塞时，对已获得资源保持不放不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系从JDK5.0开始，java提供了更强大的线程同步机制----通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当
ReentrantLock类实现了Lock，它拥有synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁
语句：
class A{ private final ReentrantLock lock=new ReentrantLock(); public void f(){ lock.lock(); try{ //保证线程安全代码 }catch(){ }finally{ lock.unlock(); //如果同步代码有异常，要将unlock（）写入finally语句块 } } } public class TestLock { public static void main(String[] args) { TestLock2 testLock2 = new TestLock2(); new Thread(testLock2).start(); new Thread(testLock2).start(); new Thread(testLock2).start(); } } class TestLock2 implements Runnable{ int num=10; private final ReentrantLock lock=new ReentrantLock(); @Override public void run() { while(true){ try{ lock.lock(); if(num>0){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(num--); }else { break; } }finally{ lock.unlock(); } } } }synchronized和Lock对比
Lock是显式锁（手动开启和关闭锁，别忘了关闭锁），synchronized是隐式锁，出了作用域自动释放Lock只有代码块锁，synchronized有代码块锁和方法锁使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性（提供更多的子类）优先使用顺序：Lock>同步代码块>同步方法>为什么使用Lambda表达式：
避免匿名内部类定义过多可以让代码看起来简洁去掉一堆没有意义的代码，只留下核心的逻辑（params）->expression[表达式]
（params）->statement[语句]
（params）->{statements}
例：new Thread(()->System.out.println(“多线程学习…”)).start();
好处：
代理对象可以做很多真实对象做不了的事情真是对象专注做自己的事情以结婚使用婚庆公司举例
public class staticProxy { public static void main(String[] args) { new MarryManage(new You()).HappyMarry(); } } //具体实例，结婚的人 class You implements Marry{ @Override public void HappyMarry() { System.out.println("结婚很开心"); } } //结婚这件事的接口 interface Marry{ void HappyMarry(); } //婚庆公司负责代理结婚事项 class MarryManage implements Marry{ private Marry target; @Override public void HappyMarry() { before(); this.target.HappyMarry(); after(); } public MarryManage(Marry target) { this.target = target; } private void after() { System.out.println("结束"); } private void before() { System.out.println("开始"); } }多线程静态代理比较
new MarryManage(new You()).HappyMarry(); new Thread(()->System.out.println("***")).start();并发协作模型“生产者/消费者模式”—>管程法
生产者：负责生产数据的模块消费者：负责处理数据的模块缓冲区：消费者不能直接使用生产者的数据，他们之间有个缓冲区，生产者将生产好的数据放入缓冲区。消费者从缓冲区拿出数据生产者消费者模式
public class TestPC1 { public static void main(String[] args) { SynContainer container=new SynContainer(); new Productor(container).start(); new Consumer(container).start(); } } //生产者 class Productor extends Thread{ SynContainer container; public Productor(SynContainer container){ this.container=container; } @Override public void run() { for(int i=0;i<100;i++){ container.push(new Chicken(i)); System.out.println("生产了"+i+"只鸡"); } } } //消费者 class Consumer extends Thread{ SynContainer container; public Consumer(SynContainer container){ this.container=container; } @Override public void run() { for(int i=0;i<100;i++){ System.out.println("消费者消费了"+container.pop().id+"只鸡"); } } } //产品 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){ if(count==chickens.length){//如果容器满了，就需要等待消费者消费 try { this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } chickens[count]=chicken; count++; this.notifyAll();//通知消费者消费 } //消费者消费产品 public synchronized Chicken pop(){ if(count==0){//判断能否消费 try { this.wait();//等待生产者生产 } catch (InterruptedException e) { e.printStackTrace(); } } count--; Chicken chicken=chickens[count]; this.notifyAll();//吃完了通知生产者生产 return chicken; } }提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
好处：
提高响应速度（减少了创建线程的时间）降低资源消耗（重复利用线程池中线程，不需要每次都创建）便于线程管理ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
1. void execute(Runnable command):执行任务、命令，没有返回值，一般用来执行Runnable 2. <T>Future<T>submit(Callable<T> task):执行任务，有返回值，一般用来执行Callable 3. void shutdown():关闭连接池Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
public class TestPool { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(10); executorService.execute(new MyThread()); executorService.execute(new MyThread()); executorService.execute(new MyThread()); executorService.execute(new MyThread()); executorService.shutdown(); } } class MyThread implements Runnable{ @Override public void run() { System.out.println(Thread.currentThread().getName()); } }