Java多线程技术概述
介绍多线程之前要介绍线程，介绍线程则离不开过程。
首先 ，
过程 ：是一个正在执行中的程序，每一个过程执行都有一个执行程序，该程序是一个执行门路，或者叫一个管制单元；
线程：就是过程中的一个独立管制单元，线程在管制着过程的执行。一个过程中至多有一个过程。
多线程：一个过程中不只有一个线程。
一、线程与过程
过程：艰深来解释就是一个程序，一个App,关上工作管理器能够看到以后电脑中正在运行的过程。
线程：一个过程中个别蕴含多个线程，关上工作管理器也能够看到以后电脑中正在运行的线程每个各自执行本人的工作来实现过程的运行，当一个过程中的最初一个线程完结时，整个过程就完结了。
线程的6种状态：
- NEW（未启动的线程）
- RUNNABLE（执行的线程）
- BLOCKED（被阻塞的线程）
- WAITING（无限期期待的线程）
- TIMED_WAITING（有限期期待的线程）
- TERMINATED（已完结的线程）
二、Java中线程创立的三种形式
1.Thread类： 通过创立一个类来继承Thread类，在这个类中重写run()办法，通过这个类创立的对象就是一个线程。
class MyThread extends Thread{ @Override public void run() { //执行的Java语句 }}public static void main(String[] args) { MyThread t = new MyThread(); //线程启动 t.start();}2.Runnable接口：通过创立一个类来实现Runnable接口，在这个类中重写run()办法，通过这个类创立的对象是一个线程工作，咱们将这个工作传给一个Thread对象即可执行这个线程工作。（举荐应用这种形式，传入一个Runnable工作即可执行线程，跟应用线程池无关）
class MyRunnable implements Runnable{ @Override public void run() { //执行的Java语句 }}public static void main(String[] args) { MyRunnable r = new MyRunnable1(); Thread t = new Thread(r); t.start();}3.Callable接口（很少用的形式）：创立形式与Runnable类似。创立此类线程会产生一个返回值，如果主程序要获取这个返回值，则主程序会在Callable线程运行完结后再运行，不获取的话，则两个线程并行。
三、线程中一些罕用的办法
Thread的罕用办法
1.String getName() //获取该线程的名字 2.void setName(String name) //设置该线程的名字 3.void start() //线程开始 4.static Thread currentThread() //获取以后线程对象 5.static void sleep(long millis) //让以后线程休眠，进入阻塞状态，传入的参数单位为毫秒 6.void setDaemon(boolean on) //将线程设置为守护线程或者用户线程 7.void interrupt() //中断此线程 8.int getPriority() //返回此线程的优先级 9.void setPriority(int newPriority) //更改此线程的优先级 10.Thread(Runnable target) //（构造方法）传入一个Runnable工作 11.Thread(String name) //（构造方法）为线程取一个名字1、interrupt办法和stop办法
线程在运行的过程中两种中断线程的办法，一个是stop()办法，一个是interrupt()办法。
Sun公司在JDK1.2版本的时候将stop()办法改为过期了，因为这种中断线程的形式是在内部强制的，这可能会导致在中断过程数据失落，所以是不平安的。
应用interrupt()办法则是一种平安的形式，当在线程内部调用interrupt()办法时，JVM会给运行的线程传递一个异样对象，当线程接管到异样对象时，线程就会终止。
public static void main(String[] args) { Thread t = new Thread(new MyRunnable()); t.start(); t.interrupt();}2、守护线程和用户线程的设置
void setDaemon(boolean on)应用setDaemon()办法能够将一个线程设置为守护线程或者用户线程（参数为TRUE时，是守护线程，参数为FALSE时为用户线程），一个线程被创立时默认是用户线程。
当用户线程和守护线程一起运行，当用户线程完结时，则守护线程就完结。
四、线程平安
线程异步：即多条线程同时执行一个工作时，这种状况下往往是呈现数据错乱的状况，例如两个人同时对一个银行账户进行取钱，账户中有10000元，两个人同时取走5000元，后果账户中还残余5000元。所以这种线程异步的状况是十分不平安的。
线程同步：即多条线程同时执行一个工作时，，当一个线程开始执行工作线程后，为这个工作加锁，其余线程期待次线程执行完工作线程后再进行争夺执行工作的工夫片。
1、实现线程平安的办法（以售票窗口买票为例）
1.1、synchronized办法（显式锁）
同步代码块
当一个售票窗口在卖票时，其余窗口期待。
语法：synchronized (加锁对象){ //Java语句 }class Runnable implements Runnable{ private int count = 10; private Object o = new Object(); public void run() { while(true){ synchronized (o){ if(count>0){ System.out.println(Thread.currentThread().getName()+"买票中"); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } count--; System.out.println("余票："+count); }else{ break; } } } }}同步办法
过后用同步办法时，以后加锁的对象默认为以后对象this
class Runnable implements Runnable{ private int count = 10; public void run() { while(true){ boolean flag = sale(); if(!flag){ break; } } } public synchronized boolean sale(){ //判断票数是否大于0，是返回true，否返回false if(count>0){ System.out.println(Thread.currentThread().getName()+"买票中"); try { //此处休眠0.5秒 Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } //票卖出，票数减一 count--; System.out.println("余票："+count); return true; }else{ return false; } }}1.2、Lock办法（隐式锁）
应用Lock办法须要创立Lock对象，并在须要加锁是手动加锁，在须要解锁时手动解锁
class Runnable implements Runnable{ private int count = 10; private Lock l = new ReentrantLock(); public void run() { while(true){ l.lock(); if(count>0){ System.out.println(Thread.currentThread().getName()+"买票中"); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } count--; System.out.println("余票："+count); l.unlock(); }else{ l.unlock(); break; } } }}1.3、显式锁和隐式锁的区别
(1)Sync:Java中的关键字，是由JVM来保护的。是JVM层面的锁。
(2)Lock:是JDK5当前才呈现的具体的类。应用lock是调用对应的API。是API层面的锁。
(3)在应用sync关键字的时候，咱们使用者基本不必写其余的代码，而后程序就可能获取和开释锁了。那是因为当sync代码块执行实现之后，零碎会主动的让程序开释占用的锁。Sync是由系统维护的，如果非逻辑问题的话话，是不会呈现死锁的。
(4)在应用lock的时候，咱们使用者须要手动的获取和开释锁。如果没有开释锁，就有可能导致呈现死锁的景象。手动获取锁办法：lock.lock()。开释锁：unlock办法。须要配合tyr/finaly语句块来实现。
(5)Sync是不可中断的。除非抛出异样或者失常运行实现
(6)Lock能够中断的。
(7)Sync:非偏心锁
(8)lock：两者都能够的。默认是非偏心锁。ReentrantLock(boolean fair)，true是偏心锁，false是不偏心锁
五、死锁
概述
A和B两人别离进入试衣间1和试衣间2，A想等B进去后去试衣间2，本人则在试衣间1中期待，B想等A进去后去试衣间1，本人则在试衣间2中期待，最终2集体都在等对方进去，然而对方都不进去，导致始终僵持。
public class DeadLockTest { public static void main(String[] args) { A a = new A(); B b = new B(); //子线程中须要和主线程中同样的A和B对象 R r = new R(a,b); Thread t = new Thread(r); t.start(); b.say(a); }}class B{ public synchronized void say(A a){ System.out.println("BBBBB"); a.reply(); } public synchronized void reply(){ System.out.println("bbbbb"); }}class A{ public synchronized void say(B b){ System.out.println("AAAAA"); b.reply(); } public synchronized void reply(){ System.out.println("aaaaa"); }}class R implements Runnable{ private A a; private B b; public R(A a, B b) { this.a = a; this.b = b; } public void run() { a.say(b); }}六、生产者与消费者
当厨师在做菜时，服务员劳动状态，当厨师做完菜后，厨师劳动，服务员端菜进来，等服务员端空盘子回来后，服务员持续劳动，叫厨师持续做菜。顺次循环
public class Test { public static void main(String[] args) { Food f = new Food(); Cook c = new Cook(f); Waiter w = new Waiter(f); //厨师线程 new Thread(c).start(); //服务员线程 new Thread(w).start(); }}class Cook implements Runnable{ private Food f; public Cook(Food f) { this.f = f; } @Override public void run() { for(int i = 0;i<10;i++){ f.cook(i); try { //此处休眠0.5秒 Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } }}class Waiter implements Runnable{ private Food f; private boolean flag = true; public Waiter(Food f) { this.f = f; } @Override public void run() { for(int i = 0;i<10;i++){ f.get(); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } }}class Food{ private String name; private String tasty; private boolean flag = true; public Food() { } public Food(String name, String tasty) { this.name = name; this.tasty = tasty; } public boolean isFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getTasty() { return tasty; } public void setTasty(String tasty) { this.tasty = tasty; } //厨师做菜 public synchronized void cook(int i){ if(flag){ if(i % 2 == 0){ this.setName("番茄炒蛋"); this.setTasty("咸"); }else{ this.setName("糖醋排骨"); this.setTasty("酸甜"); } System.out.println("厨师做菜："+this.getName()+"，滋味："+this.getTasty()); } flag = false; //唤醒其余线程 this.notifyAll(); try { //厨师线程休眠 this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //服务员端菜 public synchronized void get(){ if(!flag){ System.out.println("服务员出菜："+this.getName()+",滋味："+this.getTasty()); } flag = true; //唤醒其余线程 this.notifyAll(); try { //服务员线程休眠 this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } }}七、线程池（理解）
概述
当程序中须要执行许多的内容很少的线程时，线程创立所破费的工夫就会多于每次线程运行的所消耗的工夫，就是导致程序的效率大大降低。应用线程池的办法就能够为程序节省下创立线程的工夫。
线程池的品种
ExecutorService service = Executors.创立办法void execute(Runnable command) //指挥线程池执行工作1.缓存线程池
工作线程传入时主动调配线程，线程不够时主动创立新线程
Executors.newCachedThreadPool() //创立缓存线程池2.定长线程池
指定线程池线程的个数，工作线程传入时主动调配线程，线程不够时残余工作线程排队期待线程池中的线程执行结束
Executors.newFixedThreadPool(int nThreads) //创立定长线程池，传入线程池中线程的个数3.单线程线程池
线程池中只有一个线程，工作线程传入时主动调配线程，一个工作执行时残余工作线程排队期待线程池中的线程执行结束
Executors.newSingleThreadExecutor() //创立单线程线程池4.周期定长线程池
指定线程池线程的个数，工作线程传入时主动调配线程，能够设定工作线程第一次执行的延时工夫和之后每次执行的间隔时间
Executors.newScheduledThreadPool(int corePoolSize) //创立周期定长线程池，传入线程池中线程的个数 service.schedule(Runnable command, long delay, TimeUnit unit) //线程定时执行，传入工作、时长和时长单位 service.scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)//周期性定时执行，传入工作，首次执行延时时长，周期距离时长和时长单位最初
欢送关注公众号：前程有光，支付一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java外围知识点总结！