java.exe至少有三个线程:一个main()主线程,一个GC线程(守护线程),一个异常处理线程
一、创建多线程的三种方式
1、通过继承Thread类(Thread实现了Runnable接口),重写run()方法;
2、通过实现Runnable接口的run()方法;
3、通过实现Callable接口的call()方法,支持泛型的返回值和抛出异常,要借助FutureTask来封装,既可以封装Callable,也可以封装Runnable;
FutureTask实现了Runnable接口,支持异步获取线程执行结果,取消执行任务,异步获取执行结果会阻塞主线程;
可以将FutureTask放入线程池中
线程池:通过线程池来创建的优点:先创建好线程再放入线程池,可以避免频繁的创建、销毁线程,提高响应速度,减小资源消耗,便于线程管理;
主要分为任务部分和线程部分,通过一个生产者消费者模型来将二者解耦
任务调度过程分三步:第一步查看是否还有空闲的核心线程;第二步查看缓存队列是否满了;第三步查看最大线程的数量
线程调度过程:抢占式调度(由系统来按优先级来决定下一个线程执行) 和 协同式调度(由线程来通知下一个线程执行)
execute():没有返回结果,只能接收Runnable类型的任务
submit():返回一个Future类型的对象,用来异步获取Callable任务的返回结果,可以接收Runnable和Callable任务
shutdown()和shutdownNow()的区别
前面三个都是通过Thread的start()方法来运行:start()启动线程,调用run()方法
继承Thread类创建多个线程要用多个对象,一个对象不能多次调用start()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class MyTreadTest { public static void main(String[] args){ MyThread mt = new MyThread("新线程1--"); //mt.run(); mt.start(); //开启多线程,开辟一个新的栈执行run() // MyThread2 mt2 = new MyThread2(); new Thread(new MyThread2(), "新线程2--").start();; for(int i=0; i<3; i++) System.out.println(Thread.currentThread().getName() +" "+ i); //匿名内部类实现多线程 new Thread(){ @Override public void run(){ System.out.println("匿名内部类1"); } }.start(); new Thread(new Runnable(){ @Override public void run(){ System.out.println("匿名内部类2"); } }).start();; } } // 创建线程的第一种方式,继承Thread类 class MyThread extends Thread{ public MyThread(){} public MyThread(String name){ super(name); } @Override public void run(){ for(int i=0; i<3; i++) System.out.println(getName() + i); } } // 创建线程的第二种方式,实现Runable接口 // 避免了单继承的局限性;增强了程序的扩展性 class MyThread2 implements Runnable{ @Override public void run(){ for(int i=0; i<3; i++) System.out.println(Thread.currentThread().getName() +" "+ i); } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
/** * 1、Callable支持泛型 * 2、call()可以抛出异常,后面捕获 * 3、call()有返回值 * */ import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; class CallableThread implements Callable<Integer>{ // 支持泛型 @Override public Integer call() throws Exception{ int s = 0; for(int i=0; i<=100; i++){ Thread.sleep(10); s += i; } return s; } } public class CallableTest { public static void main(String[] args) throws ExecutionException, InterruptedException { CallableThread ct = new CallableThread(); FutureTask<Integer> ft = new FutureTask<Integer>(ct); new Thread(ft).start(); new Thread(ft).start(); // FutureTask只会执行一次call() if(!ft.isDone()){ System.out.println("主线程执行其他任务"); } System.out.println(ft.get()); // 获得call()的返回值,会阻塞主线程 System.out.println("12345"); } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import java.util.concurrent.*; class NumberRun implements Runnable{ private int s = 0; @Override // 不能抛出异常,没有返回结果 public void run() { for(int i=0; i<100; i++) { s += i; } System.out.println(Thread.currentThread().getName()+": "+s); } } class NumberCall implements Callable<Integer>{ private int s = 0; @Override // 可以抛出异常,有返回结果 public Integer call() throws Exception { for(int i=0; i<100; i++){ s += i; } System.out.println(Thread.currentThread().getName()+": "+s); return s; } } public class ThreadPool { public static void main(String[] args) throws ExecutionException, InterruptedException { // 线程池一:Executors.newCachedThreadPool(); // 核心线程数为0,最大线程数为Integer.MAX_VALUE,空闲线程60s后被回收,允许创建大量线程,不添加任务 // 手动设置线程池参数 new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); // 线程池二:Executors.newFixedThreadPool(5); // 核心线程数和最大线程数一致,允许添加大量任务 new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); // 线程池三:Executors.newSingleThreadExecutor(); // 核心线程数和最大线程数都为1,将等待的任务放入队列,队列的最大长度为Integer.MAX_VALUE,允许添加大量任务 new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); // 线程池四:Executors.newScheduledThreadPool(); // 也是通过ThreadPoolExecutor()实现的,可以传入一个ThreadFactory对象 // 创建有10个线程的线程池 ExecutorService serviceInterface = Executors.newFixedThreadPool(10); // ThreadPoolExecutor可以设置线程池属性 ThreadPoolExecutor service = (ThreadPoolExecutor)serviceInterface; // 使用Runnable提交任务 service.execute(new NumberRun()); System.out.println("(Runnable无返回值): " + service.submit(new NumberRun()).get()); // service.execute(new NumberCall()); // 不能提交Callable任务 service.execute(new FutureTask<>(new NumberRun(), null)); // 使用Callable提交任务 service.submit(new NumberCall()); // FutureTask即可传入Callable,也可传入Runnable service.submit(new FutureTask<Integer>(new NumberCall())); // execute不能提交Callable任务,但可执行经过FutureTask封装的Callable任务,因为FutureTask实现了Runnable接口 service.execute(new FutureTask<Integer>(new NumberCall())); // 使用Callable提交任务,并获取返回值 System.out.println("获取返回值: " + service.submit(new NumberCall()).get()); // 不再接收新任务,等线程池中的任务执行完之后关闭线程池, service.shutdown(); // 不再接收新任务,不等待,直接尝试关闭线程池 // service.shutdownNow(); } }
线程的方法:
1、Thread.currentThread():获取当前线程
2、Thread.yield():释放当前CPU的执行权,线程进入就绪状态(下一次仍然有可能抢到执行权),不会抛出异常
3、Thread.sleep():阻塞当前线程,线程进入阻塞状态,抛出异常
4、join():线程a里面调用线程b的join(),则线程a进入阻塞状态,直到线程b执行完
5、线程的优先级:getPriority()、setPriority(int p)、MIN_PRIORITY=1、MAX_PRIORITY=10、NORM_PRIORITY=5(默认)
二、线程安全
1、同步代码块:通过synchronized来实现,注意Thread和Runnable的同步监视器区别
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class ThreadSecurityDemo { public static void main(String[] args){ ThreadSecutiry ts = new ThreadSecutiry(); new Thread(ts).start(); new Thread(ts).start(); new Thread(ts).start(); } } class ThreadSecutiry implements Runnable{ private int ticket = 100; Object obj = new Object(); // 所有对象只能拥有一把锁 @Override public void run(){ while(true){ synchronized(obj){ // 传入一个锁对象,可以是任意类型,this也可以 if(ticket>0){ // try{ // Thread.sleep(10); // } // catch(InterruptedException e){ // e.printStackTrace(); // } System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票"); ticket--; } } } } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
class TicketThread extends Thread { private static int ticket = 100; private static Object obj = new Object(); // 保证锁唯一 @Override public void run(){ while(true){ synchronized(TicketThread.class){ if(ticket>0) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+" 正在卖第 " +(101-ticket)+" 张票"); ticket--; }else break; } } } } public class TicketThreadTest{ public static void main(String[] args) { TicketThread tt1 = new TicketThread(); TicketThread tt2 = new TicketThread(); tt1.start(); tt2.start(); } }
2、同步方法(写一个synchronized修饰的方法)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class ThreadSecurityDemo { public static void main(String[] args){ ThreadSecutiry ts = new ThreadSecutiry(); System.out.println(ts); new Thread(ts).start(); new Thread(ts).start(); new Thread(ts).start(); } } class ThreadSecutiry implements Runnable{ private int ticket = 100; @Override public void run(){ System.out.println("this: "+this); while(true){ sellTicket(); } } // 锁对象是this public synchronized void sellTicket(){ if(ticket>0){ System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票"); ticket--; } } }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class ThreadSecurityDemo { public static void main(String[] args){ ThreadSecutiry ts = new ThreadSecutiry(); new Thread(ts).start(); new Thread(ts).start(); new Thread(ts).start(); } } class ThreadSecutiry implements Runnable{ private static int ticket = 100; @Override public void run(){ while(true){ sellTicket(); } } // 锁对象是class文件对象 public static synchronized void sellTicket(){ if(ticket>0){ System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票"); ticket--; } } }
3、锁机制:
java.util.cocurrrent.locks提供了Lock和ReadWriteLock接口,ReentrantLock实现了Lock接口,ReentrantReadWriteLock实现了ReadWriteLock接口,都是通过内部类Sync继承AQS实现;
等待可中断:没有获取到锁的线程不必一直等待获取锁,可以先执行其他任务;
可实现公平锁:线程按申请锁的顺序来获取锁,直接进入队列排队等待;非公平锁:先尝试获取锁,再进入队列排队等待,synchronized是非公平锁;
可绑定多个条件?:
Condition condition = lock.newCondition();
可以使用condition.await()和condition.signal()/signalAll()来阻塞或唤醒条件上线程,而不是像Object的notify()一样随机唤醒
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ThreadSecurityDemo { public static void main(String[] args){ ThreadSecutiry ts = new ThreadSecutiry(); new Thread(ts).start(); new Thread(ts).start(); new Thread(ts).start(); } } class ThreadSecutiry implements Runnable{ private int ticket = 100; Lock lock = new ReentrantLock(); // 所有线程只能有一把锁,如果有多个对象,这里就要设为static @Override public void run(){ while(true){ lock.lock(); if(ticket>0){ try{ Thread.sleep(10); System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票"); ticket--; } catch(InterruptedException e){ e.printStackTrace(); } finally{ lock.unlock(); } } } } }
4、ThreadLocal:
当多个线程使用一个共享变量时,ThreadLocal为每个使用这个变量的线程维护一个独立的变量副本,ThrealLocal依靠ThreadLocalMap来存储数据,key是ThreadLocal,value是存储的值,每个线程只有一个ThreadLocalMap
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import java.time.LocalDateTime; import java.util.*; import java.util.concurrent.*; public class ThreadLocalTest { private static int a = 500; public static void main(String[] args) { ThreadLocal threadLocal = new InheritableThreadLocal(); // 用于信息共享 threadLocal.set("老王"); ThreadLocal threadLocal2 = new ThreadLocal(); threadLocal2.set("老王"); System.out.println(threadLocal.get().equals(threadLocal2.get())); // true new Thread(() -> { System.out.println(threadLocal.get()); // "老王" System.out.println(threadLocal2.get()); // null System.out.println(threadLocal.get().equals(threadLocal2.get())); // false }).start(); new Thread(()->{ ThreadLocal<Integer> local = new ThreadLocal<Integer>(); while(true){ local.set(++a); //子线程对a的操作不会影响主线程中的a, 为什么这里是从22开始? try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("子线程:"+local.get()); } }).start(); a = 22; ThreadLocal<Integer> local = new ThreadLocal<Integer>(); local.set(a); while(true){ try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("主线程:"+local.get()); } } }
只能用来修饰多个线程共享的字段,无法修饰方法或者代码块
volatile可以实现可见性、有序性,不能实现原子性
ReentrantLock的原理:
ReentrantLock位于java.util.concurrent包中,可实现公平锁和非公平锁,默认是非公平锁;
内部有个抽象的静态内部类:Sync,Sync继承了AbstractQueuedSynchronizer(AQS)
lock()和tryLock()的区别:lock()在获取不到锁的时候会一直等待,而tryLock()在获取不到锁的时候不会等待
synchronized和Lock的区别?
1、synchronized属于JVM层面,Lock属于api层面(具体的类来实现)
2、synchronized在代码执行完之后会自动的释放锁;Lock要手动的加锁和释放锁
3、Lock等待可中断、可实现公平锁、可绑定多个条件
并发编程中的原子性、可见性、有序性:
原子性:要么执行完,要么不执行
可见性:一个线程修改变量之后,其他线程可立刻知道变量被修改了
有序性:执行的顺序按照代码的先后顺序执行(会存在指令重排)
线程的六种状态(生命周期):
1、新建(NEW)
2、可运行(RUNNABLE):就绪(调用start()方法,等待CPU使用权) 和 运行中(获得CPU的使用权) yield()
3、锁阻塞(BLOCKED):等待同步锁
4、无限等待(WAITING):wait(),join(),LockSupport.park(),等待其他线程的唤醒
5、计时等待(TIMED_WAITING):sleep(long time),wait(long time),join(long time)
6、被终止(TERMINATED)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class WaitAndNotify { public static void main(String[] args){ Object obj = new Object(); // 消费者 new Thread(){ @Override public void run(){ synchronized(obj){ try{ System.out.println(Thread.currentThread().getName()+"进入waitting状态,释放锁对象"); obj.wait(); //进入无限等待状态 } catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"被唤醒"); } } }.start(); // 生产者 new Thread(){ @Override public void run(){ try{ Thread.sleep(5000); } catch(InterruptedException e){ e.printStackTrace(); } synchronized(obj){ System.out.println(Thread.currentThread().getName()+"获取到锁对象,调用notify方法,释放锁对象"); obj.notify(); // 唤醒等待的线程 } } }.start(); } }
线程通性wait()/notify()
wait():使线程进入阻塞状态,并且释放锁,sleep不会释放锁; wait()和sleep的区别? 一个来自Object和一个来自Thread
notify():随机唤醒一个阻塞的线程,被唤醒的线程不会立即拿到锁,而是去竞争锁
notifyAll():唤醒全部阻塞线程
只能在同步代码块或同步方法中配套使用,并且调用者要和同步代码块或同步方法的同步监视器一致,否则导致 "IllegalMonitorStateException" 异常
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
class Number implements Runnable{ private int i = 100; @Override public void run(){ while(true){ synchronized (this) { // 实现交互打印,线程通信? // notify(); this.notifyAll(); // synchronized是this,这里也要是this,wait也要是this if (i > 0) { try { Thread.sleep(10); // 不会释放锁 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + ": " + i--); try { this.wait(); // 会释放锁 } catch (InterruptedException e) { e.printStackTrace(); } } else { break; } } } } } public class CommunicationTest { public static void main(String[] args) { Number number = new Number(); new Thread(number,"n1").start(); new Thread(number,"n2").start(); new Thread(number,"n3").start(); } }
线程中断:
interrupt():不会中断运行中的线程(除非线程循环检测中断标志位),但是会改变中断标志位为false,有调用(sleep、wait、join等)时会抛出InterruptedException
Thread.interrupted():判断线程是否被中断,并改变中断标志位为false,后面再调用时返回false;
isInterrupted():只是判断线程是否已经中断;
并不是所有的阻塞都能中断,synchronized、I/O操作等不能被中断
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
try{ while(!Thread.interrupted()){ // 非阻塞过程中断 // do something } }catch (InterruptedException e){ // 阻塞过程中断 }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class InterruptTest2 { public static void main(String[] args) throws InterruptedException { Thread thread = new Thread(new MyThread()); thread.start(); Thread.sleep(1000); // 注意:要循环检测中断状态才能中断线程;interrupt()只是发出中断请求,如果不检测不能退出 thread.interrupt(); // main线程阻塞,阻塞时中断线程会抛出异常 thread.join(); System.out.println("end"); } } class MyThread implements Runnable{ @Override public void run(){ Thread hello = new Thread(new HelloThread()); hello.start(); try { hello.join(); } catch (InterruptedException e) { e.printStackTrace(); System.out.println("线程响应中断异常,立即中断"); } // 中断hello线程,不中断仍然会运行 hello.interrupt(); } } class HelloThread implements Runnable{ @Override public void run(){ int n = 0; // 注意 Thread.interrupted() 和 Thread.currentThread().isInterrupted()的区别 // Thread.interrupted() 第一次返回true并清除中断标志位,后面调用都是返回false // Thread.currentThread().isInterrupted()只是查询中断标志位判断是否中断 while(!Thread.interrupted()){ n++; System.out.println("*****hello world" + n + "*****"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); break; } } } }
设置中断标志中断线程:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
public class InterruptTest3 { public static void main(String[] args) throws InterruptedException { HelloTest thread = new HelloTest(); thread.start(); Thread.sleep(1); thread.flag = false; } } class HelloTest extends Thread { public volatile boolean flag = true; @Override public void run(){ int i = 0; while(flag){ System.out.println("通过设置标志来中断当前线程" + i++); } System.out.println("end"); } }
java的死锁:不同的线程分别占用对方的资源,都在等待对方释放资源
死锁检测:
1、jps确定java进程id
2、jstack -pid 可以检查死锁 (此处还没成功实验)