目录
线程实现
三种创建方式
继承Thread类
-
自定义线程类继承Thread类
-
重写run（）方法，编写线程执行体
-
创建线程对象，调用start（）方法启动线程
演示：多线程的交替执行
package JavaSE;
//创建线程方式一：继承Thread类，重写run（）方法，调用start开启线程
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 testThread = new TestThread();
testThread.start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
结论
线程不一定立即执行，CPU安排调度
实现Runnable接口
-
定义MyRunnable类实现Runnable接口
-
实现run（）方法，编写线程执行体
-
创建线程对象，调用start（）方法启动线程
演示：实现Runnable接口
package JavaSE;
//创建线程方式一：实现Runnable接口，重写run（）方法，执行线程需要丢入runnable接口实现类，调用start方法。
public class TestThread implements Runnable {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 200; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//main线程，主线程
//创建runnable接口的实现类对象
TestThread testThread = new TestThread();
//创建线程对象，通过线程对象来开启我们的线程，代理
Thread thread = new Thread(testThread);
thread.start();
//可合并为一句代码
//new Thread(testThread).start();
for (int i = 0; i < 200; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
Thread和Runnable对比
-
继承Thread类
-
子类继承Thread类具备多线程能力
-
启动线程：子类对象.start（）
-
不建议使用：避免OOP单继承局限性
-
-
实现Runnable接口
-
实现接口Runnable具有多线程能力
-
启动线程：传入目标对象+Thread对象.start（）
-
推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
-
演示：多个线程同时操作同一个对象
package JavaSE;
//多个线程同时操作同一个对象
//买火车票的例子
public class TestThread1 implements Runnable {
//票数
private int ticketNums = 10;
@Override
public void run() {
while(true){
if(ticketNums<=0){
break;
}
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"张票");
}
}
public static void main(String[] args) {
TestThread1 ticket = new TestThread1();
new Thread(ticket,"小明").start();
new Thread(ticket,"老师").start();
new Thread(ticket,"黄牛党").start();
}
}
发现问题
多个线程操作同一个资源的情况下，线程不安全，数据紊乱。
案例：龟兔赛跑
1.首先来个赛道距离，然后要离终点越来越近
2.判断比赛是否结束
3.打印出胜利者
4.龟兔赛跑开始
5.故事中是乌龟赢的，兔子需要睡觉，所以我们需要模拟兔子睡觉
6.最终，乌龟赢得了比赛
演示
package JavaSE;
//模拟龟兔赛跑
public class Race implements Runnable{
//胜利者
private 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) {
throw new RuntimeException(e);
}
}
//判断比赛是否结束
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接口，需要返回值类型
-
重写call方法，需要抛出异常
-
创建目标对象
-
创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
-
提交执行：Future<Boolean>result1 = ser.submit(1);
-
获取结果：boolean r1 = result.get()
-
关闭服务：ser.shutdownNow();
静态代理
-
你：真实角色
-
婚庆公司：代理你，帮你处理结婚的事
-
结婚：实现都实现结婚接口即可
演示：实现静态代理对比Thread
package JavaSE;
//静态代理总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//婚庆公司==Thread（）
//You（）==要调用线程的对象，调用的方法及run（）在这里就是labmda表达式实现的方法
//好处：
//代理对象可以做很多真实对象做不了的事情
//真实对象就专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
You you = new You();
new Thread( () -> System.out.println("我爱你")).start();
new WeddingCompany(new You()).HappyMarry();
/** 可简化为上面一行
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;
public WeddingCompany(Marry target){
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry(); //这就是真实对象
after();
}
private void after() {
System.out.println("结婚之后，收尾款");
}
private void before() {
System.out.println("结婚之前，布置现场");
}
}
lambda表达式
-
λ希腊字母中排序第十一位，英语名为lambda
-
-
避免匿名内部类定义过多
-
其实质属于函数式编程的概念
-
用法：
new Thread( () -> System.out.println("多线程")).start();
-
为什么要使用lambda表达式
-
避免匿名内部类定义过多
-
可以让你的代码看起来很简洁
-
去掉了一堆没有意义的代码，只留下核心的逻辑
-
-
理解Functional Interface（函数式接口）是学习Java8 lambda表达式的关键所在
-
函数式接口的定义：
-
任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
-
-
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
-
演示1：lambda表达式的推导
package JavaSE;
//推导lambda表达式
public class TestLambda {
//3.静态内部类
static class Like1 implements ILike{
@Override
public void lambda() {
System.out.println("i like lambda1");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
like = new Like1();
like.lambda();
//4.局部内部类
class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("i like lambda2");
}
}
like = new Like2();
like.lambda();
//5.匿名内部类,没有类的名称，必须借助接口或者父类
like = new ILike(){
@Override
public void lambda() {
System.out.println("i like lambda3");
}
};
like.lambda();
//6.用lambda简化
like = ()->{
System.out.println("i like lambda4");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike{
void lambda();
}
//2.实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("i like lambda");
}
}
演示2：lambda表达式的简化
package JavaSE;
public class TestLambda1 {
public static void main(String[] args) {
ILove love = null;
/* //1.lambda表达简化
ILove love =(int a)-> {
System.out.println("I love you-->"+a);
};
//简化1.参数类型
love = (a)-> {
System.out.println("I love you-->"+a);
};
//简化2.简化括号
love = a->{
System.out.println("I love you-->"+a);
};*/
//简化3.去掉花括号
love = a-> System.out.println("I love you-->"+a);
love.love(521);
}
}
//实现类
interface ILove{
void love(int a);
}
总结
-
lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹
-
前提是接口为函数式接口
-
多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号
975
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
