多线程
多个线程同时或交替运行, 单核CPU为顺序执行(交替执行), 多核情况下, 每个CPU有自己的运算器, 所以在多个CPU中可以同时运行.
创建线程的方式
1.继承Thread
public class MyThread extends Thread {
@Override
public void run() {
super.run();
System.out.println(Thread.currentThread().getName() + "执行完毕");
}
}
public class ThreadTest {
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.setName("测试");
myThread.start();
System.out.println(Thread.currentThread().getName() + "执行完毕");
}
}
开始线程, 可以看出main线程和测试线程是两个独立的线程
调用myThread.run();方法相当于直接在主线程运行run方法, 而不是开启一个新的线程去执行
2.实现Runnable接口
public class MyRunable implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行完毕");
}
}
public class ThreadTest {
public static void main(String[] args) {
MyRunable runable = new MyRunable();
Thread thread = new Thread(runable);
thread.start();
System.out.println(Thread.currentThread().getName() + "执行完毕");
}
}
3.使用线程池
3.1 可以在spring中配置相关线程池, 使用时从容器取出即可, 也可以自己声明线程池
<bean id="threadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<!-- 核心线程数，默认为1 -->
<property name="corePoolSize" value="5"/>
<!-- 最大线程数，默认为Integer.MAX_VALUE -->
<property name="maxPoolSize" value="20"/>
<!-- 队列最大长度，一般需要设置值>=notifyScheduledMainExecutor.maxNum；默认为Integer.MAX_VALUE
<property name="queueCapacity" value="1000" /> -->
<!-- 线程池维护线程所允许的空闲时间，默认为60s -->
<property name="keepAliveSeconds" value="300"/>
<!-- 队列最大长度 -->
<property name="queueCapacity" value="2000"/>
<!-- 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者 -->
<property name="rejectedExecutionHandler">
<!-- AbortPolicy:直接抛出java.utils.concurrent.RejectedExecutionException异常 -->
<!-- CallerRunsPolicy:主线程直接执行该任务，执行完之后尝试添加下一个任务到线程池中，可以有效降低向线程池内添加任务的速度 -->
<!-- DiscardOldestPolicy:抛弃旧的任务、暂不支持；会导致被丢弃的任务无法再次被执行 -->
<!-- DiscardPolicy:抛弃当前任务、暂不支持；会导致被丢弃的任务无法再次被执行 -->
<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy"/>
</property>
</bean>
3.2 Executors 创建线程池
public class ThreadTest {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
threadPool.execute(new MyRunable());
}
}
}
当手动创建线程池时, 如果IDEA安装阿里 P3C 插件后会报错提示以下内容, 建议
线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
说明： Executors 返回的线程池对象的弊端如下：
1） FixedThreadPool 和 SingleThreadPool:
允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。
2） CachedThreadPool 和 ScheduledThreadPool:
允许的创建线程数量为 Integer.MAX_VALUE， 可能会创建大量的线程，从而导致 OOM。
建议使用如下方式:
public class ThreadTest {
public static void main(String[] args) {
// 定时任务 建议为线程起名
ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(3,
new BasicThreadFactory.Builder().namingPattern("example-schedule-pool-%d").build());
executorService.scheduleAtFixedRate(new MyRunable(), 0, 1, TimeUnit.SECONDS);
}
}
public class ThreadTest {
public static void main(String[] args) {
// 线程工厂
ThreadFactory namedThreadFactory = new ThreadFactoryBuilder()
.setNameFormat("demo-pool-%d").build();
//Common Thread Pool
ExecutorService pool = new ThreadPoolExecutor(5, 20, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(1024), namedThreadFactory, new ThreadPoolExecutor.AbortPolicy());
pool.execute(()-> System.out.println(Thread.currentThread().getName()));
pool.shutdown();//gracefully shutdown
}
}
线程优先级
1.myThread.setPriority(1);设置优先级
2.优先级从低到高为 1-10, Thread类提供 Thread.MIN_PRIORITY=1, Thread.NORM_PRIORITY=5, Thread.MAX_PRIORITY=10
3.默认优先级为 5 即 NORM_PRIORITY
4.优先级高的仅代表获取进入运行机会的几率大, 并不代表一定会比优先级低的先执行
sleep()和wait()
1.sleep()线程未释放锁, 时间结束后线程继续执行
2.wait线程释放锁, 需要使用notify或notifyAll
3.wait常用于线程之间的交互
package com.liuzhihang.tool.alternate;
/**
* 交替打印奇偶数
*
* @author liuzhihang
* @date 2018/9/4 18:39
*/
public class AlternateNum {
public static void main(String[] args) {
Num num = new Num();
Thread thread1 = new Thread(new Odd(num));
Thread thread2 = new Thread(new Even(num));
thread1.start();
thread2.start();
}
}
class Num {
int anInt = 1;
boolean flag = true;
}
class Odd implements Runnable {
private Num num;
public Odd(Num num) {
this.num = num;
}
@Override
public void run() {
while (num.anInt < 1000) {
// 使用同一把锁
synchronized (num) {
if (num.flag) {
System.out.println("奇数 -> " + num.anInt);
num.anInt++;
num.flag = false;
num.notify();
} else {
try {
num.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
class Even implements Runnable {
private Num num;
public Even(Num num) {
this.num = num;
}
@Override
public void run() {
while (num.anInt < 1000) {
// 使用同一把锁
synchronized (num) {
if (!num.flag) {
System.out.println("偶数 -> " + num.anInt);
num.anInt++;
num.flag = true;
num.notify();
} else {
try {
num.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
