多线程
多线程
多线程简介
单线程：有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。如，去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网。
多线程：有多个任务可以同时执行。如，去网吧上网，网吧能够让多个人同时上网。
线程时独立的执行路径，main()为主线程，线程的运行由调度器安排调度，由操作系统决定，人为不能干涉多线程运行先后顺序。
线程实现
线程创建
Thread class：
继承Thread类（重点），不建议使用（避免oop单继承局限性）
1.自定义线程类继承Thread类（子类继承Thread类具备多线程能力）
2.重写run()方法，编写线程执行体
3.创建线程对象，调用start()方法启动线程（子类对象.start()）
注意：线程开启不一定立即执行，由cpu调度执行
package com.peace.demo01;
public class TestThread1 extends Thread {
@Override
public void run(){
for (int i = 0;i < 200;i++){
System.out.println("我在看代码--"+i);
}
}
public static void main(String[] args) {
//创建一个线程对象
TestThread1 testThread1 = new TestThread1();
//调用start()方法开启线程
testThread1.start();
for (int i = 0;i < 1000;i++){
System.out.println("我在学多线程--"+i);
}
}
}
Runnnable接口：
实现Runnable接口（重点），推荐使用（避免单继承局限性，灵活方便，方便同一个对象被多个线程使用）
1.定义类实现Runnable接口（实现Runnable接口具备多线程能力）
2.重写run()方法，编写线程执行体
3.创建线程对象，调用start()方法启动线程（传入目标对象+Thread对象.start()）
package com.peace.demo01;
public class TestThread2 implements Runnable {
@Override
public void run() {
for (int i = 0;i < 200;i++){
System.out.println("我在看代码--"+i);
}
}
public static void main(String[] args) {
//创建runnable接口的实现类对象
TestThread2 testThread2 = new TestThread2();
//创建线程对象，通过线程对象来开启我们的线程，代理
// Thread thread = new Thread(testThread2);
// thread.start();
new Thread(testThread2).start();
for (int i = 0;i < 1000;i++){
System.out.println("我在学多线程--"+i);
}
}
}
多个线程同时操作同一个对象
package com.peace.demo01;
/**
* 多个线程同时操作同一个对象
* 买火车票的例子
* 发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
*/
public class TestThread3 implements Runnable{
//票数
private int ticketNums = 10;
@Override
public void run() {
while (true){
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (ticketNums <= 0){
break;
}
System.out.println(Thread.currentThread().getName()+"-->拿到了 第"+ticketNums-- +"张票");
}
}
public static void main(String[] args) {
TestThread3 ticket = new TestThread3();
new Thread(ticket,"小明").start();
new Thread(ticket,"小红").start();
new Thread(ticket,"小帅").start();
}
}
Callable接口：
实现Callable接口（了解），可以定义返回值，抛出异常
1.实现Callable接口，需要返回值类型
2.重写call方法，需要抛出异常
3.创建目标对象
4.创建执行服务：ExectorService ser = Exectors.newFixedThreadPool(1);1为池数
5.提交执行：Future result1 = ser.submit(t1);
6.获取结果：boolean r1 = result1.get();
7.关闭服务：ser.shutdownNow();
静态代理模式
真实对象和代理对象都要实现同一个接口
代理对象要代理真实对象
好处：代理对象可以做很多真实对象做不了的事情，真实对象专注做自己的事情
Lambda表达式
用途：
1.避免匿名内部类定义过多
2.可以让代码看起来很简洁
3.去掉了一堆没有意义的代码，只留下核心的逻辑
函数式接口
定义：
其实质属于函数式编程的概念
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
//1.定义一个函数式接口
interface ILike{
void lambda();
}
对于函数式接口，可以通过lambda表达式来创建该接口的对象
package com.peace.lambda;
//推导lamda表达式，从2到6逐步简化代码
public class TestLambda1 {
//3.静态内部类
static class Like2 implements ILike{
@Override
public void lambda(int a) {
System.out.println("I like lambda2-->"+a);
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda(1);
like = new Like2();
like.lambda(2);
//4.局部内部类
class Like3 implements ILike{
@Override
public void lambda(int a) {
System.out.println("I like lambda3-->"+a);
}
}
like = new Like3();
like.lambda(3);
//5.匿名内部类，没有类的名称，必须借助接口或者父类
like = new ILike(){
@Override
public void lambda(int a) {
System.out.println("I like lambda4-->"+a);
}
};
like.lambda(4);
//6.用lambda简化定义实现类
like = (int a)->{
System.out.println("I like lambda5-->"+a);
};
like.lambda(5);
//6.1 简化参数类型
like = (a)->{
System.out