Process 与 Thread
进程 : 执行程序的一次过程, 是一个动态的概念. 是系统资源分配的单位
线程 : 一个进程中可以包含若干个线程. 是CPU调度和执行的最小单位
核心概念
- 线程就是独立的执行路径
- 在程序运行时, 即使自己没有创建线程, 后台也会有多个线程, 如主线程和 gc 线程等
- main() 称之为主线程, 是系统的入口, 用于执行整个程序
- 在一个进程中, 如果开辟了多线程, 线程的运行由调度器安排调度, 调度器是与操作系统紧密相关的, 先后顺序不受人为干预
- 对同一份资源操作时, 会存在资源抢夺问题, 需要加入并发控制
- 线程会带来额外的开销, 如CPU调度时间, 并发控制开销
- 每个线程在自己的工作内存交互, 内存控制不当会造成数据不一致
线程创建
- Thread class : 继承 Thread 类
- Runnable 接口 : 实现 Runnable 接口
- Callable 接口 : 实现 Callable 接口
调用 run 方法和 start 方法的区别
调用 start 方法才能实现多线程效果！
继承Thread类
package com.guanxing.lesson01;
//创建线程方式一:继承Thread类, 重写run()方法, 调用start开启线程
//总结:注意! 线程开启不一定立即执行, 由cpu调度
public class TestThread extends Thread{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码---" + i);
}
}
public static void main(String[] args) {
//main线程, 主线程
//创建一个线程对象, 调用start方法开启线程
TestThread testThread1 = new TestThread();
// testThread1.run();
testThread1.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程---" + i);
}
}
}
实现Runable接口
package com.guanxing.lesson01;
//创建线程方式二：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class TestThread2 implements Runnable{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 500; 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);
}
}
}
小结
- 继承Thread类
- 启动线程：子类对象.start()
- 实现Runnable接口
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用！
TestThread testThread1 = new TestThread();
testThread1.start();
TestThread2 testThread2 = new TestThread2();
Thread thread = new Thread(testThread2);
thread.start();
静态代理模式
package com.guanxing.StaticProxy;
//静态代理模式总结：真实对象和代理对象都要代理同一个接口！
//代理对象要代理真实角色
//好处：
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
//实例化用户jay
User jay = new User();
//将用户jay丢给婚庆公司
WeddingCompany weddingCompany = new WeddingCompany(jay);
weddingCompany.HappyMarry();
//静态代理和线程的类比
// new 代理类( 真实对象 ).执行方法;
new Thread( ()-> System.out.println("我爱你") ).start();
new WeddingCompany(new User()).HappyMarry();
}
}
//实现一个结婚接口
interface Marry {
void HappyMarry();
}
//定义一个用户类
//真实对象
class User implements Marry {
@Override
public void HappyMarry() {
System.out.println("我要结婚了，超开心！");
}
}
//定义婚庆公司类
//代理角色，代理用户去结婚
class WeddingCompany implements Marry {
//要代理的真实角色
private Marry target;
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
before();
target.HappyMarry();
after();
}
private void before() {
System.out.println("婚礼之前，布置现场");
}
private void after() {
System.out.println("婚礼之后，收尾款...");
}
}
Lambda表达式
函数式接口：
- 只包含唯一一个抽象方法的任意接口
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
public interface Runnable {
public abstract void run();
}
演变推导
package com.guanxing.lambda;
/*
推导lambda表达式
*/
public class TestLambda01 {
//3.静态内部类
static class Like2 implements ILike {
@Override
public void lambda() {
System.out.println("i like lambda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike {
@Override
public void lambda() {
System.out.println("i like lambda3");
}
}
like = new Like3();
like.lambda();
//5.匿名内部类（没有类的名称，必须借助接口或父类）
like = new ILike() {
@Override
public void lambda() {
System.out.println("i like lambda4");
}
};
like.lambda();
//6.用lambda简化
like = () -> {
System.out.println("i like lambda5");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike {
void lambda();
}
//2.实现类
class Like implements ILike {
@Override
public void lambda() {
System.out.println("i like lambda");
}
}
package com.guanxing.lambda;
public class TestLambda02 {
public static void main(String[] args) {
// ILove love = (int a) -> {
// System.out.println("i love you--->"+a);
// };
// love.love(520);
//终极简化版
ILove love = null;
love = a -> System.out.println("i love you--->"+a);
love.love(520);
//总结：
//lambda表达式在只有一行代码的情况下才能去掉花括号！
//前提是接口为函数式接口
//多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号
}
}
//定义函数时接口
interface ILove {
void love(int a);
}
优点：
- 避免匿名内部类定义过多
- 简化代码，只留下核心逻辑