Java 多线程 自习功课笔记
线程简介
(任务,进程,线程,多线程 )
多任务:examp:吃饭玩手机
多线程:多条道路解决一条道路阻塞的问题,多条线路同时跑起来。
普通方法调用和多线程:
程序.进程(Process).线程(Thread):
一个进程可以有多个线程。如视频中同时听声音,图像,看弹幕等等
进程:是执行程序的一次执行过程,它是一个动态的概念。是系统分配资源的单位。
线程:是CPU调度和执行的单位
线程创建
Thread class:继承Thread类
//创建线程方式一:继承Thread类,重写run()方法,调用start开启线程
//总结:线程开启不一定立即执行,由CPU调度执行
public class TestThread1 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线程,主线程
//创建一个线程对象
TestThread1 testThread1=new TestThread1();
//调用start()方法开启线程
testThread1.start();
for (int i = 0; i < 2000; i++) {
System.out.println("我在学习多线程"+i);
}
}
}
Runnable 接口:实现Runnable接口
//创建线程方式2:实现Runnable接口,重写run方法,
// 执行线程需要丢入runnable接口实现类,调用start方法
public class TestThread2 implements Runnable {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("我在努力" + i);
}
}
public static void main(String[] args) { //main线程,主线程
//创建runnable接口的实现类对象
TestThread2 testThread2 = new TestThread2();
new Thread(testThread2).start();
for (int i = 0; i < 2000; i++) {
System.out.println("我在学习多线程" + i);
}
}
}
龟兔赛跑代码:
//模拟龟兔赛跑
public class Race implements Runnable {
//胜利者
private static String winner;
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
//模拟兔子休息
if(Thread.currentThread().getName().equals("兔子")&&i%10==0){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(i);
//如果比赛结束了,就停止程序
if (flag) {
break;
}
System.out.println(Thread.currentThread().getName()+"--->跑了"+i+"步");
}
}
//判断是否完成比赛
private boolean gameOver(int steps) {
if (winner != null) {//存在胜利者了
return true;
}
{
if (steps >= 100) {
winner = Thread.currentThread().getName();
System.out.println("winner is" + winner);
return true;
}
}
return false;
}
public static void main(String[] args) {
Race race=new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
Callable 接口:实现Callable接口
public class TestThread3 implements Callable<String> {
private String msg;
public TestThread3(String msg) {
this.msg = msg;
}
@Override
public String call() throws Exception {
//相关业务代码
System.out.println("当前城市是"+msg);
return msg;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
TestThread3 t1 = new TestThread3("山东");
TestThread3 t2 = new TestThread3("上海");
TestThread3 t3 = new TestThread3("北京");
//创建执行服务
ExecutorService ser= Executors.newFixedThreadPool(3);
//提交执行
Future<String> r1= ser.submit(t1);
Future<String> r2= ser.submit(t2);
Future<String> r3= ser.submit(t3);
System.out.println(r1.get());
System.out.println(r2.get());
System.out.println(r3.get());
//关闭服务
ser.shutdownNow();
}
}
静态代理模式:
其实线程底部的实现原理就是:
如: TestThread2 testThread2 = new TestThread2();
new Thread(testThread2).start();
WeddingCompany相当于Thread类,Marry就是Runnable接口。
//静态代理模式总结:真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处:代理对象可以做很多真实对象做了不了的事情
//真实对象专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.HappyMarry();
}
}
interface Marry {
void HappyMarry();
}
//真实角色,你去结婚
class You implements Marry {
@Override
public void HappyMarry() {
System.out.println("你给新娘戴戒指");
}
}
//代理角色,婚庆公司帮助你结婚
class WeddingCompany implements Marry {
private Marry target;
WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void HappyMarry() {
System.out.println("结婚前");
this.target.HappyMarry();
System.out.println("结婚后");
}
}
Lambda表达式
函数式接口的定义:任何接口,如果只包含唯一一个抽象方法,
那么他就是一个函数式接口。
对于函数式接口,我们可以通过lambda表达式来创建该接口的对象。
//推导lambda表达式
public class TestLambda {
//3.静态内部类
static class Like2 implements ILike {
@Override
public void lambda(int a) {
System.out.println("I like lambda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda(1);
like = new Like2();
like.lambda(1);
//4.局部内部类
class Like3 implements ILike {
@Override
public void lambda(int a) {
System.out.println("I like lambda3");
}
}
like=new Like3();
like.lambda(1);
//5.匿名内部类,没有类的名称,必须借助接口或者父类
like=new ILike() {
@Override
public void lambda(int a) {
System.out.println("I like lambda4");
}
};
like.lambda(1);
//6.用lambda简化
//总结:
//lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,就需要用代码块包裹
//前提是接口必须为函数式接口
//多个参数也可以去掉参数类型,要去掉就都去掉,必须加上括号
like=(a)->{
System.out.println("I like lambda5"+a);
};
like.lambda(520);
like=a->{
System.out.println("I like lambda6"+a);
};
like.lambda(520);
like=a->System.out.println("I like lambda7"+a);
like.lambda(520);
}
}
//1.定义一个函数式接口
interface ILike {
void lambda(int a);
}
//2.实现类
class Like implements ILike {
@Override
public void lambda(int a) {
System.out.println("I like lambda");
}
}
这一次就先到这,代码都是自己一个一个敲的,加油,道阻且长,一起加油