多线程
线程的三种创建方式
- 继承Thread类
- 自定义线程类继承Thread类
- 重写run方法，编写线程执行体
- 创建线程对象，调用start方法启动线程
注意：线程不一定立即执行，由CPU安排调度
package com.nocilantro.ThreadDemo;
/**
* 创建线程的方法一：继承Thread类，重写run方法，调用start方法开启线程
* 注意：线程开启不一定立即执行，由CPU调度执行
*/
public class Demo01 extends Thread{
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println("Hello");
}
}
public static void main(String[] args) {
// 创建一个线程对象
Demo01 demo01 = new Demo01();
// 调用start方法开启线程
demo01.start();
for (int i = 0; i < 1000; i++) {
System.out.println("我在执行多线程");
}
}
}
package com.nocilantro.ThreadDemo;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
/**
* 练习Thread，实现多线程同步下载图片
*/
public class Demo02 extends Thread{
private String url; // 网络图片地址
private String name; // 保存的文件名
public Demo02(String url, String name) {
this.url = url;
this.name = name;
}
@Override
public void run() { // 线程体
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url, name);
System.out.println("下载了文件名为：" + name);
}
public static void main(String[] args) {
// 创建线程对象
Demo02 t1 = new Demo02("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3355464299,584008140&fm=26&gp=0.jpg", "test1.jpg");
Demo02 t2 = new Demo02("https://ss1.baidu.com/9vo3dSag_xI4khGko9WTAnF6hhy/zhidao/pic/item/1b4c510fd9f9d72aa19da8a7d52a2834359bbb8b.jpg", "test2.jpg");
Demo02 t3 = new Demo02("https://ss1.bdstatic.com/70cFuXSh_Q1YnxGkpoWK1HF6hhy/it/u=3355464299,584008140&fm=26&gp=0.jpg", "test3.jpg");
// 同时执行
t1.start();
t2.start();
t3.start();
}
}
// 下载器
class WebDownloader {
// 下载方法
public void downloader(String url, String name) {
try {
FileUtils.copyURLToFile(new URL(url), new File(name));
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常，downloader方法出现问题");
}
}
}
- 实现Runnable接口
注意：因为java单继承局限性，推荐使用Runnable接口
package com.nocilantro.ThreadDemo;
/**
* 创建线程方式二：实现Runnable接口，重写run方法，执行线程需要丢入runnable接口的实现类，调用start方法
*/
public class TestThread implements Runnable{
public static void main(String[] args) {
// 创建Runnable接口的实现类
TestThread testThread = new TestThread();
// 创建线程对象，通过线程对象来开启线程 （代理）
Thread thread = new Thread(testThread);
thread.start();
for (int i = 0; i < 1000; i++) {
System.out.println("我在执行多线程");
}
}
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println("Hello");
}
}
}
-
实现Callable接口（了解）
-
需要返回值类型
-
重写call方法，需要抛出异常
-
创建目标对象
-
创建执行服务：ExecutorService serive = Executors.newFixedThreadPool(1);
-
提交执行：Future result = service.submit(t1);
-
获取结果：boolean r1 = result.get();
-
关闭服务：service.shutdownNow();
-
Lambda表达式
实质是函数式编程：
- (params) -> expression
- (params) -> statement
- (params) -> { statements }
例如：new Thread( () -> System.out.println(“lambda expression”) ).start()
为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 简洁
- 去掉无意义代码，留下核心逻辑
函数式接口
- 定义：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
public interface Runnable {
public abstract void run();
}
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
静态代理
结婚案例：
package com.nocilantro.StaticProxyDemo;
/**
* 静态代理模式总结：
* 真实对象和代理对象都要实现同一个接口
* 代理对象要代理真实角色
* 好处：
* 代理对象可以做很多真实对象做不了的事
* 真实对象专注做自己的事
*/
public class StaticProxy {
public static void main(String[] args) {
You you = new You(); // 真实要结婚的人
WeddingCompany weddingCompany = new WeddingCompany(you); // 代理的婚庆公司
weddingCompany.HappyMarry();
// Thread和WeddingCompany对比
// new Thread(() -> System.out.println("")).start();
// new WeddingCompany(() -> System.out.println("Gotta Marry")).HappyMarry();
}
}
interface HappyMarriage {
void HappyMarry();
}
真实角色
//class You implements HappyMarriage {
// @Override
// public void HappyMarry() {
// System.out.println("Gotta Marry");
// }
//}
// 代理角色，帮助操办结婚的事
class WeddingCompany implements HappyMarriage {
private HappyMarriage target; // 代理谁 => 真实对象
public WeddingCompany(HappyMarriage target) {
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry(); // 这就是真实角色
after();
}
private void before() {
System.out.println("结婚之前，布置现场");
}
private void after() {
System.out.println("结婚之后，收尾款");
}
}
线程的状态
-
创建状态
-
就需状态
-
运行状态
-
阻塞状态
-
死亡状态
停止线程：
- 不推荐使用JDK提供的stop()、destroy()方法
- 推荐线程自己停止下来
- 建议使用一个标志位进行终止变量（当flag=false，则终止线程运行）
package com.nocilantro.StateDemo;
/**
* 测试stop
* 建议线程正常停止 -> 利用次数，不建议死循环
* 建议使用标志位 -> 设置一个标志位
*
*/
public class TestStop implements Runnable{
private boolean flag = true;
public static void main(String[] args) {
TestStop demo01 = new TestStop();
new Thread(demo01).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main " + i);
if (i == 900) {
demo01.stop();
System.out.println("线程该停止了");
}
}
}
@Override
public void run() {
int i = 0;
while (flag) {
System.out.println("Running..." + i++);
}
}
// 设置一个公开的方法停止线程，转换标志位
public void stop() {
this.flag = false;
}
}
线程休眠：
- sleep方法的单位 毫秒：1000毫秒 = 1秒
- sleep存在异常InterruptedException;
- sleep时间到达后线程进入就绪状态
- sleep可以模拟网络延时，倒计时等
- 每一个对象都有一个锁，sleep不会释放锁
package com.nocilantro.StateDemo;
/**
* 测试sleep：模拟网络延时 => 放大问题的发生性
* 多个人拿到同一张票
*/
public class TestSleep01 implements Runnable{
private int ticketNum = 10;
@Override
public void run() {
while (true) {
if (ticketNum <= 0) {
break;
}
// 模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " --> 拿到了第" + ticketNum-- + "张票");
}
}
public static void main(String[] args) {
TestSleep01 ticket = new TestSleep01();
new Thread(ticket, "Leo").start(); // 线程可以有名字
new Thread(ticket, "Jerry").start();
new Thread(ticket, "Jason").start();
}
}
package com.nocilantro.StateDemo;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 模拟倒计时
*/
public class TestSleep02 {
public static void tenDown() throws InterruptedException {
int num = 10;
while (true) {
Thread.sleep(1000);
Date date = new Date(System.currentTimeMillis());
System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
date = new Date(System.currentTimeMillis());
if (--num <= 0) {
break;
}
}
}
public static void main(String[] args) {
try {
tenDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程礼让：
- 让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转为就绪状态
- 让cpu重新调度，礼让不一定成功
package com.nocilantro.StateDemo;/** * 测试yield * 礼让不一定成功 */public class TestYield { public static void main(String[] args) { MyYield myYield = new MyYield(); new Thread(myYield, "a").start(); new Thread(myYield, "b").start(); }}class MyYield implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName() + "->Start"); Thread.yield(); System.out.println(Thread.currentThread().getName() + "->End"); }}
Join：
- Join合并线程，等待此线程执行完毕后，再执行其他线程，其他线程阻塞
- 可以想象成插队
package com.nocilantro.StateDemo;/** * 测试join * 想象为插队 */public class TestJoin implements Runnable{ @Override public void run() { for (int i = 0; i < 1000; i++) { System.out.println("I'm vip -> " + i); } } public static void main(String[] args) throws InterruptedException { // 启动线程 TestJoin testJoin = new TestJoin(); Thread thread = new Thread(testJoin); thread.start(); // 主线程 for (int i = 0; i < 200; i++) { if (i == 50) { thread.join(); // 插队；thread执行完了再执行主线程 } System.out.println("main -> " + i); } }}
线程状态观测：
package com.nocilantro.StateDemo;/** * 观察测试线程状态 */public class TestState { public static void main(String[] args) { Thread thread = new Thread(() -> { for (int i = 0; i < 5; i++) { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("///"); } }); // 观察状态 System.out.println(thread.getState()); // New thread.start(); System.out.println(thread.getState()); // Run while (thread.getState() != Thread.State.TERMINATED) { // 只要线程不终止，就一直输出状态 try { Thread.sleep(100); System.out.println(thread.getState()); // 输出状态 } catch (InterruptedException e) { e.printStackTrace(); } } thread.start(); }}
线程的优先级：
- 优先级由数字表示 （1-10）：
- Thread.MIN_PRIORITY = 1
- Thread.MAX_PRIORITY = 1
- Thread.NORM_PRIORITY = 5
- 使用以下方法改变或获取优先级
- getPriority(), setPriority(int priority)
package com.nocilantro.StateDemo;/** * 测试线程的优先级 */public class TestPriority implements Runnable{ public static void main(String[] args) { // 主线程默认优先级 System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority()); TestPriority testPriority = new TestPriority(); Thread thread1 = new Thread(testPriority); Thread thread2 = new Thread(testPriority); Thread thread3 = new Thread(testPriority); Thread thread4 = new Thread(testPriority); Thread thread5 = new Thread(testPriority); Thread thread6 = new Thread(testPriority); // 先设置优先级, 在启动 thread1.start(); thread2.setPriority(1); thread2.start(); thread3.setPriority(4); thread3.start(); thread4.setPriority(Thread.MAX_PRIORITY); thread4.start();// thread5.setPriority(-1);// thread5.start(); thread6.setPriority(11);// thread6.setPriority(11); } @Override public void run() { System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority()); }}
守护（daemon）线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕，如后台记录操作日志，监控内存，垃圾回收等待。。。
package com.nocilantro.StateDemo;/** * 测试守护线程 */public class TestDaemon { public static void main(String[] args) { God god = new God(); Person person = new Person(); Thread godThread = new Thread(god); godThread.setDaemon(true); // 设置为守护线程 godThread.start(); new Thread(person).start(); }}// 人class Person implements Runnable{ @Override public void run() { for (int i = 0; i < 36500; i++) { System.out.println("开心地活着 -->" + i); } System.out.println("Goodbye, world!"); }}class God implements Runnable { @Override public void run() { while (true) { System.out.println("上帝保佑着你"); } }}
线程的同步
并发：同一个对象被多个线程同时操作
线程同步：一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池，等待前面线程使用完毕，下个线程再使用
形成条件：队列+锁 解决安全性
关键词：synchronized
当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能倒置问题
同步方法
-
Public synchronized void method() {}
-
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
-
缺陷：若将一个大的方法声明为synchronized将会影响效率
同步块
- synchronized(Obj) {}
- Obj称为同步监视器，推荐使用共享资源作为同步监视器
死锁
多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的情况。某一个同步块同时拥有两个以上对象的锁时，就可能会发生“死锁”问题
条件：
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源的关系
package com.nocilantro.DeadlockDemo;/** * 死锁：多个线程互相拥有对方需要的资源，然后形成僵持 */public class Demo01 { public static void main(String[] args) { Makeup p1 = new Makeup(0, "qiuqiu"); Makeup p2 = new Makeup(1, "bibi"); p1.start(); p2.start(); }}class Lipstick {}class Bag {}class Makeup extends Thread{ // 需要的资源只有一份，用static修饰 static Lipstick lipstick = new Lipstick(); static Bag bag = new Bag(); int choice; String name; public Makeup(int choice, String name) { this.choice = choice; this.name = name; } @Override public void run() { try { makeup(); } catch (InterruptedException e) { e.printStackTrace(); } } private void makeup() throws InterruptedException { if (choice == 0) { synchronized (lipstick) { // 获得口红的锁 System.out.println(this.name + "获得口红的锁"); Thread.sleep(1000); synchronized (bag) { // 一秒后获得包包的锁 System.out.println(this.name + "获得包包的锁"); } } } else { synchronized (bag) { System.out.println(this.name + "获得包包的锁"); synchronized (lipstick) { System.out.println(this.name + "获得口红的锁"); } } } }}
Lock（锁）
- JDK5
- ReentrantLock类实现了Lock（可重入锁）
package com.nocilantro.LockDemo;import java.util.concurrent.locks.ReentrantLock;/** * 测试Lock */public class Demo01 { public static void main(String[] args) { BuyTicket b1 = new BuyTicket(); new Thread(b1).start(); new Thread(b1).start(); new Thread(b1).start(); }}class BuyTicket implements Runnable{ private int ticketNum = 10; // 定义Lock private final ReentrantLock lock = new ReentrantLock(); @Override public void run() { while (true) { try { // 模拟延时 try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } lock.lock(); // 加锁 if (ticketNum <= 0) { break; } System.out.println(Thread.currentThread().getName() + " --> 拿到了第" + ticketNum-- + "张票"); } finally { lock.unlock(); // 解锁 } } }}
synchronized和lock的对比
- Lock是显式锁（手动开启和关闭锁）synchronized是隐式锁，出了作用于自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
- 优先使用顺序：Lock > 同步代码块（已经进入方法体，分配了相应的资源） > 同步方法（在方法体之外）
线程协作
生产者消费者问题：线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
线程通信方法
- wait() 表示线程一直等待，直到其他线程通知。与sleep不同，会释放锁
- wait(long timeout) 指定等待的毫秒数
- notify() 唤醒一个处于等待状态的线程
- notifyAll() 唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度
注意：只能在同步方法或者同步代码块中使用，否则会抛出异常IllegalMonitorStateException
线程池
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁，实现重复利用。
好处：
- 提高响应速度
- 降低资源消耗
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后才会终止
相关类：ExecutorService和Executors（工具类）
ExecutorService：真正的线程池接口
- void execute(Runnable command) 执行任务，没有返回值，一般用来执行Runnable
- Future submit(Callable task) 执行任务，有返回值，一般用来执行Callable
- void shutdown() 关闭线程池
package com.nocilantro.LockDemo;import java.util.concurrent.Executor;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** * 测试线程池 */public class TestPool { public static void main(String[] args) { // 创建服务，创建线程池 ExecutorService executorService = Executors.newFixedThreadPool(10); // 执行 executorService.execute(new MyThread()); executorService.execute(new MyThread()); executorService.execute(new MyThread()); executorService.execute(new MyThread()); // 关闭服务 executorService.shutdownNow(); }}class MyThread implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName()); }}
3157
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
