Java多线程
1. 创建线程的方法
继承Thread类
继承Thread类，重写run方法，通过**线程类实例.start()**方法开启线程。
public class TestThread1 extends Thread{ @override public void run(){ System.out.println("线程run方法！"); } public static void main(String){ new TestThread1().start(); } }实现Runnable接口
实现Runnable接口，重写run方法，通过**new Thread(线程类实例).start()**开启线程
推荐使用该方式，避免java的单继承局限性
public class TestThread2 implements Runnable{ @Override public void run() { System.out.println("线程run方法！"); } public static void main(String[] args) { new Thread(new TestThread2()).start(); } }实现Callable接口
实现Callable接口，重写call方法，call方法有返回值
启动方式：
创建执行服务
提交执行
获取结果
关闭服务
public class TestThread2 implements Callable{ @Override public Boolean call() { System.out.println("线程call方法！"); return true; } public static void main(String[] args) throws InterruptedException, ExecutionException { TestThread2 t1 = new TestThread2(); TestThread2 t2 = new TestThread2(); TestThread2 t3 = new TestThread2(); //创建执行服务 ExecutorService ser = Executors.newFixedThreadPool(3); //提交执行 Future<Boolean> r1 = ser.submit(t1); Future<Boolean> r2 = ser.submit(t2); Future<Boolean> r3 = ser.submit(t3); //获取结果 boolean rs1 = r1.get(); boolean rs2 = r2.get(); boolean rs3 = r3.get(); //关闭服务 ser.shutdownNow(); }
2. 线程同步
多个线程同时操作同一资源，线程不安全，变量值紊乱
- 加锁
队列+锁(synchronized)
synchronized默认锁this，可以显示指定锁的对象来修改
- synchronized修饰方法，线程安全方法
public class TestThreadSafe {
public static void main(String[] args) {
BuyTicket bt1 = new BuyTicket();
Thread thread1 = new Thread(bt1,"张三");
Thread thread2 = new Thread(bt1,"李四");
Thread thread3 = new Thread(bt1,"黄牛");
thread1.start();
thread2.start();
thread3.start();
}
}
class BuyTicket implements Runnable{
private int ticketNumber = 10;
private boolean flag = true;
@Override
public void run() {
while(flag) {
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void buy() throws InterruptedException {
//买票
if(ticketNumber <= 0){
System.out.println("票卖完了！");
flag = false;
return;
}
Thread.sleep(100);
//Thread.yield();
System.out.println(Thread.currentThread().getName() + "买到了一张票，还剩下"+(--ticketNumber) + "张票！");
}
}
- synchronized修饰代码块，线程安全代码块
public class TestThreadSafe {
public static void main(String[] args) {
BuyTicket bt1 = new BuyTicket();
Thread thread1 = new Thread(bt1,"张三");
Thread thread2 = new Thread(bt1,"李四");
Thread thread3 = new Thread(bt1,"黄牛");
thread1.start();
thread2.start();
thread3.start();
}
}
class BuyTicket implements Runnable{
private int ticketNumber = 10;
private boolean flag = true;
@Override
public void run() {
while(flag) {
System.out.println(Thread.currentThread().getName() + "准备买票" + flag);
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void buy() throws InterruptedException {
synchronized(this){
//买票
if(ticketNumber <= 0){
flag = false;
System.out.println("票卖完了！");
return;
}
Thread.sleep(100);
//Thread.yield();
System.out.println(Thread.currentThread().getName() + "买到了一张票，还剩下"+(--ticketNumber) + "张票！");
}
}
}
- 使用可重复锁ReentrantLock
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
BuyTicket bt1 = new BuyTicket();
Thread thread1 = new Thread(bt1,"张三");
Thread thread2 = new Thread(bt1,"李四");
Thread thread3 = new Thread(bt1,"黄牛");
thread1.start();
thread2.start();
thread3.start();
}
}
class BuyTicket implements Runnable{
private int ticketNumber = 1000;
private boolean flag = true;
//定义可重复锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while(flag) {
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void buy() throws InterruptedException {
lock.lock();
//买票
if(ticketNumber <= 0){
System.out.println("票卖完了！");
flag = false;
}else {
Thread.sleep(100);
//Thread.yield();
System.out.println(Thread.currentThread().getName() + "买到了一张票，还剩下"+(--ticketNumber) + "张票！");
}
lock.unlock();
}
}
死锁
两个以上的对象锁，每个线程互相占有对方需要的资源。形成死锁。
3. 线程状态
- 新生状态（new）
- 就绪状态（start）
- 阻塞状态（sleep、wait、同步锁定）
- 运行状态
- 死亡状态 线程对象进入死亡状态后，将不能再次调用start()方法再次启动
4. 线程（Thread类）方法
setPriority(int newPriority) 更改线程优先级 newPriority从1到10
static void sleep(long millis) 使当前正在执行的线程休眠指定毫秒，不会释放线程锁对象
void join() 线程合并，等待该线程终止
static void yield() 暂停当前正在执行的线程，执行其它线程
void interrupt() 中断线程
boolean isAlive() 该线程是否活跃
5. 守护线程
setDaemon(true) : 设置为守护线程
线程分为用户线程和守护线程
JVM虚拟机确保用户线程执行完毕
JVM虚拟机不用等待守护线程执行完毕
eg：后台记录操作日志，监控内存，垃圾回收等待
6. 线程池
- 为什么要使用线程池？频繁的创建和销毁线程对象，会消耗资源。
- 线程池的说明：
线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。下面会对这7个参数一一解释。
一、corePoolSize 线程池核心线程大小
线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会 被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。
二、maximumPoolSize 线程池最大线程数量
一个任务被提交到线程池后，首先会缓存到工作队列（后面会介绍）中，如果工作队列满了，则会创建一个新线程，然后从工作队列中的取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize来指定。
三、keepAliveTime 空闲线程存活时间
一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定
四、unit 空间线程存活时间单位
keepAliveTime的计量单位
五、workQueue 工作队列
新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：
①ArrayBlockingQueue
基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。
②LinkedBlockingQuene
基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。
③SynchronousQuene
一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。
④PriorityBlockingQueue
具有优先级的无界阻塞队列，优先级通过参数Comparator实现。
六、threadFactory 线程工厂
创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等
七、handler 拒绝策略
当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略，就是解决这个问题的，jdk中提供了4中拒绝策略：
①CallerRunsPolicy
该策略下，在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。
②AbortPolicy
该策略下，直接丢弃任务，并抛出RejectedExecutionException异常。
③DiscardPolicy
该策略下，直接丢弃任务，什么都不做。
④DiscardOldestPolicy
该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列