一、实现多线程
多线程是为了同步完成多项任务，提高资源使用率提高系统使用率。
1、继承Thread类
| void run() |
在线程开启后，此方法将被调用执行，run()封装了被线程执行的代码 |
| void start() |
启动线程，Java虚拟机会调用run方法()、即由JVM调用此线程的run()方法 |
public class MultiThreaded extends Thread{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("继承thread " + i);
}
}
public static void main(String[] args) {
MultiThreaded multiThreaded = new MultiThreaded();
MultiThreaded multiThreaded1 = new MultiThreaded();
multiThreaded.start();
multiThreaded1.start();
}
}
2、实现Runnable接口
| Thread(Runnable target) |
分配一个新的Thread对象 |
| Thread(Runnable target, String name) |
分配一个新的Thread对象 |
public class RunnableThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + i);
}
}
public static void main(String[] args) {
RunnableThread run = new RunnableThread();
//创建Thread类的对象，把RunnableThread对象作为构造方法的参数
Thread is = new Thread(run, "is");
Thread lunatic = new Thread(run, "lunatic");
//启动线程
is.start();
lunatic.start();
}
}
3、实现Callable接口
| V call() |
计算结果，如果无法计算结果，则抛出一个异常 |
| FutureTask(Callable callable) |
创建一个 FutureTask，一旦运行就执行给定的 Callable |
| V get() |
如有必要，等待计算完成，然后获取其结果 |
public class CallableThread implements Callable {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 100; i++) {
sum += i;
}
//返回值就表示线程运行完毕之后的结果
return sum;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
//线程开启之后需要执行里面的call方法
CallableThread call = new CallableThread();
//可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象
FutureTask task = new FutureTask<>(call);
//创建线程对象
Thread thread = new Thread(task);
//开启线程
thread.start();
Integer str = task.get();
System.out.println("str = " + str);
}
}
4、对比
| 实现 |
好处 |
坏处 |
| 实现Runnable、Callable接口 |
扩展性强，实现该接口的同时还可以继承其他的类 |
编程相对复杂，不能直接使用Thread类中的方法 |
| 继承Thread |
编程比较简单，可以直接使用Thread类中的方法 |
可以扩展性较差，不能再继承其他的类 |
5、线程调度
| 分时调度模型 |
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片 |
| 抢占式调度模型 |
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些 |
线程优先级：默认优先级是5；设置优先级在1~10之间。
6、线程同步
同步代码块
public class RunnableThread implements Runnable {
private int tickets = 100;
private Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) { // 对可能有安全问题的代码加锁,多个线程必须使用同一把锁
//t1进来后，就会把这段代码给锁起来
if (tickets > 0) {
try {
Thread.sleep(100);
//t1休息100毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--; //tickets = 99;
}
}
//t1出来了，这段代码的锁就被释放了
}
}
public static void main(String[] args) {
RunnableThread run = new RunnableThread();
//创建Thread类的对象，把RunnableThread对象作为构造方法的参数
Thread is = new Thread(run, "is");
Thread lunatic = new Thread(run, "lunatic");
//启动线程
is.start();
lunatic.start();
}
}
| 好处 |
解决了多线程数据安全问题 |
| 坏处 |
当线程有多个，每个线程都会去判断同步上的锁，造成资源耗费严重，降低程序运行效率 |
同步方法
public class TbRunnable implements Runnable{
private static int ticketCount = 100;
@Override
public void run() {
while(true){
if("is".equals(Thread.currentThread().getName())){
//同步方法
boolean result = synchronizedMethod();
if(result){
break;
}
}
if("lunatic".equals(Thread.currentThread().getName())){
//同步代码块
synchronized (TbRunnable.class){
if(ticketCount == 0){
break;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
}
}
}
}
}
private static synchronized boolean synchronizedMethod() {
if(ticketCount == 0){
return true;
}else{
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
ticketCount--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");
return false;
}
}
public static void main(String[] args) {
TbRunnable tb = new TbRunnable();
Thread t1 = new Thread(tb);
Thread t2 = new Thread(tb);
t1.setName("is");
t1.setName("lunatic");
t1.start();
t2.start();
}
}
Lock锁：unlock(释放锁)和lock(获得锁)
public class Ticket implements Runnable {
//票的数量
private int ticket = 100;
private Object obj = new Object();
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
//synchronized (obj){//多个线程必须使用同一把锁.
try {
lock.lock();
if (ticket <= 0) {
//卖完了
break;
} else {
Thread.sleep(100);
ticket--;
System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
// }
}
}
public static void main(String[] args) {
Ticket tk = new Ticket();
Thread t1 = new Thread(tk);
Thread t2 = new Thread(tk);
Thread t3 = new Thread(tk);
t1.setName("ttt1");
t2.setName("ttt2");
t3.setName("ttt3");
t1.start();
t2.start();
t3.start();
}
}
8、线程池
存放线程的容器
Executors线程池
public class MyThreadPoolDemo {
public static void main(String[] args) throws InterruptedException {
//1,创建一个默认的线程池对象.池子中默认是空的.默认最多可以容纳int类型的最大值.
ExecutorService executorService = Executors.newCachedThreadPool();
//Executors --- 可以帮助我们创建线程池对象
//ExecutorService --- 可以帮助我们控制线程池
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
Thread.sleep(2000);
executorService.submit(()->{
System.out.println(Thread.currentThread().getName() + "在执行了");
});
executorService.shutdown();
}
}
ThreadPoolExecutor线程池
| corePoolSize |
核心线程的最大值，不能小于0 |
| maximumPoolSize |
最大线程数，不能小于等于0，maximumPoolSize >= corePoolSize |
| keepAliveTime |
空闲线程最大存活时间,不能小于0 |
| unit |
时间单位 |
| workQueue |
任务队列，不能为null |
| threadFactory |
创建线程工厂,不能为null |
| handler |
任务的拒绝策略,不能为null |
public class MyThreadPoolDemo3 {
// 参数一：核心线程数量
// 参数二：最大线程数
// 参数三：空闲线程最大存活时间
// 参数四：时间单位
// 参数五：任务队列
// 参数六：创建线程工厂
// 参数七：任务的拒绝策略
public static void main(String[] args) {
ThreadPoolExecutor pool = new ThreadPoolExecutor(2,5,2, TimeUnit.SECONDS,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
pool.submit(new RunnableThread());
pool.submit(new RunnableThread());
pool.shutdown();
}
}
