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
该策略下,抛弃进入队列最早的那个任务,然后尝试把这次拒绝的任务放入队列