文章目录
1. 线程、进程、多线程
Process进程就是执行程序的一次执行过程。
Thread一个进程中可以包含若干个线程。
2. 线程的创建
继承Thread类
实现Runnable接口(推荐)
实现Callable接口(了解)
3. Thread
- 自定义线程类继承Thread类
- 重写run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
public class StartThread1 extends Thread {
//线程的入口点
@Override
public void run(){
//线程体
for(int i = 0; i < 20; i++){
System.out.println("我在听课====");
}
}
public static void main(String[] args) {
//创建线程对象
StartThread t = new Startthread1();
//调用start()方法开启线程
t.start();
}
}
总结:线程开启不一定立即执行,由CPU调度
4. 实现Runnable
- 定义MyRunnable类实现Runnable接口
- 实现run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
public class TestThread3 implements Runnable{
@Override
public void run(){
//线程体
for(int i = 0; i < 20; i++){
System.out.println("我在听课====");
}
}
public static void main(String[] args) {
//创建runnable接口的实现类对象
TestThread3 testThread3 = new TestThread3();
//创建线程对象,通过线程对象来开启我们的线程(代理)
// Thread thread = new Thread(testThread3);
// thread.start();
new Thread(testThread3).start();
}
}
5. 初始并发问题
火车站卖票
public class TestThread4 implements Runable {
//票数
private int ticketNums = 10;
@Override
public void run() {
while(true) {
if (ticketNums <= 0) {
break;
}
//模拟延迟
try{
Thread.sleep(200);
} catch (InterrupteException e) {
e.printStackTrace();
}
//通过这个方法可以拿到当前执行线程的名字,没拿到一张票,票数就-1
System.out.println(Thread.currentThread().getName() + "--->拿到了第" + ticketNums-- + "票");
}
}
pubic static void main(String[] args) {
TestThread4 ticket = new TestThread4();
//三个线程
new Thread(ticket, "小明").start();
new Thread(ticket, "老师").start();
new Thread(ticket, "黄牛党").start();
}
}
07. 龟兔赛跑
//模拟龟兔赛跑
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(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//判断比赛是否结束
boolean flag = gameOver(i);
if(flag){
break;
}
//打印线程名 + 跑了i步
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();
}
}
09. 静态代理
//静态代理模式总结:
//真实对象和代理对象都要实现同一个接口
//代理对象必须要代理真实角色
//好处:代理对象可以做很多真实对象做不了的事情,真实对象专注做自己的事情
public class StaticProxy {
public static void main(String[] args) {
//Thread类相当于一个company,代理真实对象
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{
//代理谁--->target:通过WeddingCompany()传递过来
private Marry target;
public WeddingCompany(Marry target) {
this.target = 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("结婚前,布置现场");
}
}
10. lambda表达式
//为什么要使用lambda表达式?
//避免匿名内部类定义过多,可以让代码看起来更简洁
//Functional Interface函数式接口:只包含唯一一个抽象方法的接口
public class LambdaShi {
//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");
}
}
11. 线程停止
推荐让线程自己停下来,建议使用一个标志位进行终止变量:当flag == false时,终止线程运行。
//1 建议线程正常停止---利用次数,不建议死循环
//2 使用标志位
//3 不要用stop或destroy
//推荐方式:
public class TestStop implements Runnable{
//1 设置一个标识位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while(flag){
System.out.println("run....Thread" + i++);
}
}
//2 设置一个公开的方法停止线程,转换标志位
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for(int i = 0; i < 1000; i++){
System.out.println("main" + i);
if(i == 900) {
//调用stop方法切换标志位,让线程停止
testStop.stop();
System.out.println("该线程已停止");
}
}
}
}
12. 线程休眠
//模拟延时
public class TestSleep implements Runnable{
//票数
private int ticketNums = 10;
@Override
public void run() {
while (true) {
if (ticketNums <= 0) {
break;
}
//模拟延时
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"--->拿到了第"+ ticketNums-- +"--->票");
}
}
public static void main(String[] args) {
TestSleep ticket = new TestSleep();
new Thread(ticket,"小明").start();
new Thread(ticket,"老师").start();
new Thread(ticket,"黄牛党").start();
}
}
//模拟倒计时
public class TestSleep2 {
public static void main(String[] args) {
//倒计时:一秒钟跑一下
// try {
// tenDown();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//打印当前系统时间
Date startTime = new Date(System.currentTimeMillis()); //获取系统当前时间
while (true) {
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime = new Date(System.currentTimeMillis()); //更新当前时间
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void tenDown() throws InterruptedException{
int num = 10;
//一秒钟跑一下
while (true) {
Thread.sleep(1000);
System.out.println(num--);
if (num <= 0){
break;
}
}
}
}
13. 线程礼让
让当前正在执行的线程暂停,但不阻塞
将线程从运行状态转为就绪状态
//测试礼让
//礼让不一定成功,看CPU心情
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程开始执行");
Thread.yield(); //礼让
System.out.println(Thread.currentThread().getName() + "线程终止执行");
}
}
礼让成功:
b线程开始执行
a线程开始执行
b线程终止执行
a线程终止执行
14. 线程强制执行
插队是非常霸道的方法,插队的线程全部执行完,才可以继续执行其他线程
//插队
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("线程vip来了"+i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
//主线程
for (int i = 0; i < 500; i++) {
if(i == 200){
thread.join();//插队
}
System.out.println("main" + i);
}
}
}
15. 观测线程状态
- 新建(NEW):新创建了一个线程对象。
- 可运行(RUNNABLE):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权 。
- 运行(RUNNING):可运行状态(runnable)的线程获得了cpu 时间片(timeslice) ,执行程序代码。
- 阻塞(BLOCKED):阻塞状态是指线程因为某种原因放弃了cpu 使用权,暂时停止运行。
- 死亡(DEAD):线程run()、main() 方法执行结束,或者因异常退出了run()方法,则该线程结束生命周期。死亡的线程不可再次复生
//测试线程的状态
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
//让它休息一下,补获异常
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);
//观察启动后
thread.start();//启动线程
state = thread.getState();
System.out.println(state);//Run
while (state != Thread.State.TERMINATED){
//只要线程不终止,就一直输出状态
Thread.sleep(100);
state = thread.getState(); //更新线程状态
System.out.println(state);
}
}
}
结果:
NEW
RUNNABLE //正在运行
//因为main方法里写了个延迟,要睡觉5秒钟,所以一直在等待
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
//等待结束时,输出这句话
TERMINATED //线程停止,不能再运行了
16. 线程的优先级
线程调度器按照优先级决定应该调度哪个线程来执行
线程优先级:1~10
//测试线程的优先级
public class TestPriority {
public static void main(String[] args) {
//主线程默认优先级5
System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
Thread t5 = new Thread(myPriority);
Thread t6 = new Thread(myPriority);
//先设置优先级,再启动
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);//最大是10
t4.start();
t5.setPriority(8);
t5.start();
t6.setPriority(7);
t6.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "-->" + Thread.currentThread().getPriority());
}
}
17. 守护线程
线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕,如后台操作记录、监控内存
//测试守护线程
//上帝守护你
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
You you = new You();
//让上帝变成守护线程
Thread thread = new Thread(god);
thread.setDaemon(true); //默认是false表示是用户线程,正常线程都是用户线程
thread.start();//上帝守护线程启动
new Thread(you).start(); //你 用户线程启动
}
}
//上帝
class God implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝保佑着你");
}
}
}
//你
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("你一生都开心的活着");
}
System.out.println("====goodbye!world====");
}
}
18. 线程同步机制
线程同步:多个线程操作同一个资源
并发:同一个对象被多个线程同时操作
例如:上万个人抢100张票
队列和锁:
锁机制synchronized
19. 三大不安全案例
//不安全的买票: 线程不安全,有负数
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"小明").start();
new Thread(buyTicket,"老师").start();
new Thread(buyTicket,"黄牛党").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true; //外部停止方式
@Override
public void run() {
//买票
while (true){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
//判断是否有票
if(ticketNums <= 0){
return;
}
//模拟延时
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
}
}
//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100, "结婚基金");
Drawing you = new Drawing(account, 50, "你");
Drawing girlFriend = new Drawing(account, 100, "女朋友");
you.start();
girlFriend.start();
}
}
class Account{
int money; //余额
String name; //卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行:模拟取款
class Drawing extends Thread{
Account account; //账户
//取了多少钱
int drawingMoney;
//现在手里有多少钱
int nowMoney;
public Drawing(Account account, int drawingMoney, String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
@Override
public void run() {
//判断有没有钱
if(account.money - drawingMoney < 0){
System.out.println(Thread.currentThread().getName()+"钱不够");
return;
}
//模拟延时: 可以放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 取的钱
account.money = account.money - drawingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + "余额为:" +account.money);
//Thread.currentThread().getName()等价于this.getName(), 因为继承了Thread
System.out.println(this.getName() + "手里的钱" + nowMoney);
}
}
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
//一万条线程
for (int i = 0; i < 10000; i++) {
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
System.out.println(list.size());
//打印出来不是10000,所以不安全
}
}
20. 同步方法及同步块
同步方法:public synchronized void method(int args) {}
synchronized
方法控制对象的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行。
缺点:锁太多,浪费资源
同步块:synchronized(Obj) {}
//不安全的买票: 线程不安全,有负数
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"小明").start();
new Thread(buyTicket,"老师").start();
new Thread(buyTicket,"黄牛党").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean flag = true; //外部停止方式
@Override
public void run() {
//买票
while (true) {
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
synchronized (this) {
//判断是否有票
if (ticketNums <= 0) {
return;
}
//模拟延时
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName() + "拿到" + ticketNums--);
}
}
}
//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100, "结婚基金");
Drawing you = new Drawing(account, 50, "你");
Drawing girlFriend = new Drawing(account, 100, "女朋友");
new Thread(you).start();
new Thread(girlFriend).start();
}
}
class Account{
int money; //余额
String name; //卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行:模拟取款
class Drawing extends Thread{
Account account; //账户
//取了多少钱
int drawingMoney;
//现在手里有多少钱
int nowMoney;
public Drawing(Account account, int drawingMoney, String name) {
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
//synchronized 默认锁的是this
@Override
public void run() {
//锁的对象就是变化的量,需要增删改的量
synchronized (account) {
//判断有没有钱
if (account.money - drawingMoney < 0) {
System.out.println(Thread.currentThread().getName() + "钱不够");
return;
}
//模拟延时: 可以放大问题的发生性
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 取的钱
account.money = account.money - drawingMoney;
//你手里的钱
nowMoney = nowMoney + drawingMoney;
System.out.println(account.name + "余额为:" + account.money);
//Thread.currentThread().getName()等价于this.getName(), 因为继承了Thread
System.out.println(this.getName() + "手里的钱" + nowMoney);
}
}
}
//线程不安全的集合
public class UnsafeList {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
//一万条线程
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list) {
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
//打印出来不是10000,所以不安全
}
}
21. JUC
22. 死锁
//步骤:两个对象:口红、镜子;都要去化妆,只有一份资源,解决办法:放弃已获资源
//死锁:多个线程互相抱着对方需要的资源,然后形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0, "灰姑娘");
Makeup g2 = new Makeup(1, "白雪公主");
g1.start();
g2.start();
}
}
//口红
class Lipstick{
}
//镜子
class Mirror{
}
//画在
class Makeup extends Thread{
//需要的资源只有一份,用static来保证只有一份
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice; //选择
String girlName; //使用化妆品的人
public Makeup(int choice, String girlName) {
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
//化妆
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//化妆,互相持有对方的锁,就是需要拿到对方的资源
private void makeup() throws InterruptedException {
if(choice == 0){
synchronized (lipstick){ //获得口红的锁
System.out.println(this.girlName+"获得口红的锁");
Thread.sleep(1000);
}
synchronized (mirror){ //一秒钟后想获得镜子
System.out.println(this.girlName+"获得镜子的锁");
}
} else {
synchronized (mirror){ //获得镜子的锁
System.out.println(this.girlName+"获得镜子的锁");
Thread.sleep(2000);
}
synchronized (lipstick){ //两秒钟后想获得口红
System.out.println(this.girlName+"获得口红的锁");
}
}
}
}
23. Lock锁
ReentrantLock类实现了Lock接口
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
//多个线程操作同一个对象(出现-1,不安全)
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable {
int ticketNums = 10;
//定义lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock(); //加锁
//票数 > 0时,买一张票; 票数 = 0时,停止
if (ticketNums > 0) {
//模拟延时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNums--);
} else {
break;
}
} finally {
//解锁
lock.unlock();
}
}
}
}
四、线程协作
25. 管程法
生产者和消费者共享同一个资源,并且生产者和消费者相互依赖。
Java提供了几个方法解决线程之间的通信
- 生产者:负责生产数据的模块
- 消费者负责处理数据的模块
- 缓冲区:消费者不能直接使用生产者的数据
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据
//测试:生产者消费者模型--->利用缓冲区解决:管程法
//生产者,消费者,产品,缓冲区
/*生产者只管生产,消费者只管消费,生产者和消费者同时跑,
生产者生产完了,消费者开始消费,消费者消费完,生产者立马生产,轮流的过程
利用一个缓冲区,把产品放入缓冲区,如果缓冲区满了,生产者就等待;
如果没有满就把产品放进去,通知消费者可以消费了
*/
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
//生产者和消费者同时跑
new Productor(container).start();
new Consumer(container).start();
}
}
//生产者
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container){
this.container = container;
}
//生产
@Override
public void run() {
for (int i = 0; i < 100; i++) {
container.push(new Chicken(i));
System.out.println("生产了 "+i+" 只鸡");
}
}
}
//消费者
class Consumer extends Thread{
SynContainer container;
public Consumer(SynContainer container) {
this.container = container;
}
//消费
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了-->"+container.pop().id+"只鸡");
}
}
}
//产品
class Chicken{
int id; //产品编号
public Chicken(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer{
//需要一个容器大小
Chicken[] chickens = new Chicken[10];
//容器计数器
int count = 0;
//生产者放入产品
public synchronized void push(Chicken chicken){
//如果容器满了,就需要等待消费者消费
if(count == chickens.length){
//通知消费者消费,生产等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没有满,我们就需要丢入产品
chickens[count] = chicken;
count++;
//可以通知消费者消费了
this.notifyAll();
}
//消费者消费产品
public synchronized Chicken pop(){
//判断能否消费
if(count == 0){
//等待生产者生产,消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果可以消费
count--;
Chicken chicken = chickens[count];
//吃完了,通知生产者生产
this.notifyAll();
return chicken;
}
}
26. 信号灯法
27. 线程池
- 思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中,可以避免频繁创建销毁、实现重复利用。
- 好处:
- 提高响应速度;
- 降低资源消耗
- 便于线程管理:
- corePooSize核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
public class TestPool {
public static void main(String[] args) {
//1. 创建服务,创建线程池
//newFixedThreadPool 参数为:线程池大小
ExecutorService service = Executors.newFixedThreadPool(10);
//执行:把线程丢进去
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//2. 关闭链接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
28. 总结
//回顾总结线程的创建
public class ThreadNew {
public static void main(String[] args) {
//第一种方法
new MyThread1().start();
//第二种方法需要一个代理类
new Thread(new MyThread2()).start();
//第三种方法仅作了解
FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
new Thread(futureTask).start();
//打印返回值
try {
Integer integer = futureTask.get();
System.out.println(integer);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//1. 继承Thread类
class MyThread1 extends Thread{
@Override
public void run() {
System.out.println("MyThread1");
}
}
//2. 实现Runnable接口
class MyThread2 implements Runnable{
@Override
public void run() {
System.out.println("MyThread2");
}
}
//3. 实现Callable接口
class MyThread3 implements Callable<Integer>{
@Override
public Integer call() throws Exception {
System.out.println("MyThread3");
return 100;
}
}