继承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线程，主线程
//创建线程对象，调用start方法开启线程，交替执行
TestThread1 thread1 = new TestThread1();
thread1.start();
for (int i = 0; i < 20; i++)
System.out.println("我在学习多线程"+i);
}
}
}
启动线程：传入目标对象+Thread对象.start()
推荐使用，避免单继承的局限性，灵活方便，方便同一个对象对多个线程使用
//创建线程方式二：实现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) {
//创建一个runnable接口的实现类对象
TestThread2 thread2 = new TestThread2();
//创建线程对象，通过线程对象来开启我们的线程，代理
Thread thread = new Thread(thread2);
thread.start();
//new Thread(thread2).start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程"+i);
}
}
}
执行结果为交替执行，表现为两个线程在同时跑：
我在学习多线程0
看代码0
看代码1
看代码2
看代码3
看代码4
看代码5
看代码6
看代码7
看代码8
看代码9
看代码10
看代码11
我在学习多线程1
我在学习多线程2
我在学习多线程3
看代码12
我在学习多线程4
看代码13
我在学习多线程5
看代码14
看代码15
看代码16
看代码17
看代码18
看代码19
我在学习多线程6
我在学习多线程7
我在学习多线程8
我在学习多线程9
我在学习多线程10
我在学习多线程11
我在学习多线程12
我在学习多线程13
我在学习多线程14
我在学习多线程15
我在学习多线程16
我在学习多线程17
我在学习多线程18
我在学习多线程19
多线程同时操作一个对象
//多个线程同时操作同一个对象
// 买火车票的例子
public class TestThread3 implements Runnable {
//票数
private int ticketNums=10;
@Override
public void run() {
while (true){
if (ticketNums<=0) break;
System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNums--+"票");
}
//模拟延迟
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
TestThread3 thread3 = new TestThread3();
new Thread(thread3,"小明").start();
new Thread(thread3,"老师").start();
new Thread(thread3,"阿涛").start();
}
}
操作结果如下所示：
老师-->拿到了第10票
老师-->拿到了第7票
老师-->拿到了第6票
老师-->拿到了第5票
小明-->拿到了第9票
阿涛-->拿到了第8票
阿涛-->拿到了第2票
阿涛-->拿到了第1票
小明-->拿到了第3票
老师-->拿到了第4票
多线程实现龟兔赛跑
//模拟龟兔赛跑
public class Race implements Runnable{
private static String winner;
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
//模拟兔子休息,没10次休息一下
if (Thread.currentThread().getName().equals("兔子")&&i%50==0){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag=gameOver(i);
//如果比赛结束了，
if (flag) break;
System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步");
}
}
//是否完成比赛
private boolean gameOver(int step) {
//判断是否有胜利者
if (winner!=null){
return true;
}
if (step==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();
}
}
操作结果如下所示：
乌龟-->跑了1步
兔子-->跑了1步
乌龟-->跑了2步
乌龟-->跑了3步
乌龟-->跑了4步
兔子-->跑了2步
乌龟-->跑了5步
乌龟-->跑了6步
乌龟-->跑了7步
乌龟-->跑了8步
乌龟-->跑了9步
乌龟-->跑了10步
兔子-->跑了3步
乌龟-->跑了11步
乌龟-->跑了12步
乌龟-->跑了13步
兔子-->跑了4步
兔子-->跑了5步
兔子-->跑了6步
兔子-->跑了7步
乌龟-->跑了14步
乌龟-->跑了15步
乌龟-->跑了16步
乌龟-->跑了17步
乌龟-->跑了18步
乌龟-->跑了19步
乌龟-->跑了20步
乌龟-->跑了21步
乌龟-->跑了22步
乌龟-->跑了23步
兔子-->跑了8步
兔子-->跑了9步
兔子-->跑了10步
兔子-->跑了11步
乌龟-->跑了24步
乌龟-->跑了25步
乌龟-->跑了26步
乌龟-->跑了27步
乌龟-->跑了28步
乌龟-->跑了29步
乌龟-->跑了30步
乌龟-->跑了31步
乌龟-->跑了32步
兔子-->跑了12步
兔子-->跑了13步
乌龟-->跑了33步
兔子-->跑了14步
乌龟-->跑了34步
兔子-->跑了15步
兔子-->跑了16步
兔子-->跑了17步
兔子-->跑了18步
兔子-->跑了19步
兔子-->跑了20步
兔子-->跑了21步
兔子-->跑了22步
兔子-->跑了23步
兔子-->跑了24步
兔子-->跑了25步
兔子-->跑了26步
兔子-->跑了27步
兔子-->跑了28步
乌龟-->跑了35步
兔子-->跑了29步
乌龟-->跑了36步
兔子-->跑了30步
乌龟-->跑了37步
兔子-->跑了31步
乌龟-->跑了38步
兔子-->跑了32步
乌龟-->跑了39步
兔子-->跑了33步
乌龟-->跑了40步
兔子-->跑了34步
兔子-->跑了35步
乌龟-->跑了41步
兔子-->跑了36步
乌龟-->跑了42步
乌龟-->跑了43步
兔子-->跑了37步
乌龟-->跑了44步
兔子-->跑了38步
兔子-->跑了39步
兔子-->跑了40步
兔子-->跑了41步
兔子-->跑了42步
乌龟-->跑了45步
兔子-->跑了43步
乌龟-->跑了46步
乌龟-->跑了47步
乌龟-->跑了48步
乌龟-->跑了49步
乌龟-->跑了50步
兔子-->跑了44步
乌龟-->跑了51步
兔子-->跑了45步
乌龟-->跑了52步
兔子-->跑了46步
乌龟-->跑了53步
兔子-->跑了47步
乌龟-->跑了54步
兔子-->跑了48步
兔子-->跑了49步
乌龟-->跑了55步
乌龟-->跑了56步
乌龟-->跑了57步
乌龟-->跑了58步
乌龟-->跑了59步
乌龟-->跑了60步
乌龟-->跑了61步
乌龟-->跑了62步
乌龟-->跑了63步
乌龟-->跑了64步
乌龟-->跑了65步
乌龟-->跑了66步
乌龟-->跑了67步
乌龟-->跑了68步
乌龟-->跑了69步
乌龟-->跑了70步
乌龟-->跑了71步
乌龟-->跑了72步
乌龟-->跑了73步
乌龟-->跑了74步
乌龟-->跑了75步
乌龟-->跑了76步
乌龟-->跑了77步
乌龟-->跑了78步
乌龟-->跑了79步
乌龟-->跑了80步
乌龟-->跑了81步
乌龟-->跑了82步
乌龟-->跑了83步
乌龟-->跑了84步
乌龟-->跑了85步
乌龟-->跑了86步
乌龟-->跑了87步
乌龟-->跑了88步
乌龟-->跑了89步
乌龟-->跑了90步
乌龟-->跑了91步
乌龟-->跑了92步
乌龟-->跑了93步
乌龟-->跑了94步
乌龟-->跑了95步
乌龟-->跑了96步
乌龟-->跑了97步
乌龟-->跑了98步
乌龟-->跑了99步
winner is :乌龟
Lambda表达式
public class TestLambda {
//2.静态内部类
static class Love2 implements ILove{
@Override
public void love(int i) {
System.out.println("I love you-->"+i);
}
}
public static void main(String[] args) {
//3.局部内部类
class Love3 implements ILove {
@Override
public void love(int i) {
System.out.println("I love you-->" + i);
}
}
ILove me = new Love();
me.love(1);
me = new Love2();
me.love(2);
me = new Love3();
me.love(3);
//4.匿名内部类
new ILove(){
public void love(int i) {
System.out.println("I love you-->" + i);
}
};
me.love(4);
//5.Lambda表达式
ILove me1=(int i)->{
System.out.println("I love you-->" + i);
};
me1.love(5);
//简化,去掉函数类型和花括号
me=i-> System.out.println("I love you-->" + i);
me.love(6);
}
}
interface ILove{
void love(int i);
}
//1.函数接口实现类
class Love implements ILove{
@Override
public void love(int i) {
System.out.println("I love you-->"+i);
}
}
操作结果如下所示：
I love you-->1
I love you-->2
I love you-->3
I love you-->4
I love you-->5
I love you-->6
总结：
- Lambda表达式只能有一行代码的情况下可以简化为一行（类比if），如果有多行，就用代码块包裹。
- 前提是接口为函数式接口，即内部只有一个方法。
- 多个参数也可以去掉参数类型，要去掉就都去掉，同时需要加上括号。
1270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
