基本概念
程序
程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程
进程是程序的一次执行过程或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
1. 如：运行中的qq,运行中的bilibili
2. 程序是静态的，进程是动态的
3. 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
线程
进程可进一步细化为线程，是一个程序内部的一条执行路径。
- 若同一个进程同一时间并行执行多个线程，就是支持多线程的。
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器，线程切换的开销小。
- 一个进程中的多个线程共享相同的内存单元和内存地址空间。->他们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
并行与并发
- **并行：**多个CPU同时执行多个任务。比如：多个人同时做不同的事。
- **并发：**一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。
线程的创建和使用
- java语言运行程序运行多个线程，java.lang.Thread类来体现。
方式一：继承于Thread类
创建方式
- 创建一个继承于Thread类的子类。
- 重写Thread类的run()—>，将此线程执行的操作声明在run()中。
- 创建Thread类的子类的对象。
- 通过此对象调用start()
例子：创建一个多线程程序，主线程遍历100以内的偶数，分线程遍历100以内的奇数
public class ThreadDemo {
public static void main(String[] args) {
// MyThread1 m1 = new MyThread1();
// MyThread2 m2 = new MyThread2();
//
// m1.start();
// m2.start();
//创建Thread类的匿名子类的方式
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
测试Thread中的常用方法：
start():
启动当前线程；调用当前线程的run()
run():
通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
currentThread():
静态方法，返回执行当前代码的线程
getName():
获取当前线程的名字
setName():
设置当前线程的名字
主线程设置名字
Thread.currentThread().setName("主线程");
分线程可以
Mythread2 m2 = new Mythread2("线程二");
但在clss里加构造器
public Mythread2(String name) {
super(name);
}
m1.setName("线程一：");
yield():
释放当前cpu的执行权。
join():
在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
for (int i = 0; i < 100; i++) { //这里是主线程
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
System.out.println(m2.isAlive());
}
if (i == 21) {
try {
m1.join(); //m1是分线程对象
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
sleep(long millitime):
让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
class Mythread1 extends Thread {
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
try {
sleep(300); //注意处理可能会出现异常
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " : " + i);
}
}
}
isAlive():
判断当前线程是否存活。
这个函数的返回值是boolean.
m2.isAlive();
线程的优先级
- 优先级分类
- MAX_PRIORITY：10
- MIN _PRIORITY：1
- NORM_PRIORITY：5 -->默认优先级
- 如何获取和设置当前线程的优先级：
-
getPriority():获取线程的优先级
-
setPriority(int p):设置线程的优先级
说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
-
设置在主函数里设置
m1.setPriority(6); m2.setPriority(3); Thread.currentThread().setPriority(10);
全部代码
public class Mythread {
public static void main(String[] args) {
Mythread1 m1 = new Mythread1();
Mythread2 m2 = new Mythread2("线程二");
m1.setName("线程一：");
m2.start();
m1.start();
m1.setPriority(6);
m2.setPriority(3);
Thread.currentThread().setPriority(10);
// new Thread() {
// public void run() {
// for (int i = 0; i < 100; i++) {
// if (i % 2 == 0) {
// System.out.println(Thread.currentThread().getName() + " : " + i);
//
// }.
// }
// }
// }.start();
Thread.currentThread().setName("主线程");
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + " : " + i+" 当前优先级 :"+Thread.currentThread().getPriority() );
System.out.println(m2.isAlive());
}
if (i == 21) {
try {
m1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class Mythread1 extends Thread {
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
try {
sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " : " + i+" 当前优先级 :"+Thread.currentThread().getPriority() );
}
}
}
}
class Mythread2 extends Thread {
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + " : " + i+" 当前优先级 :"+Thread.currentThread().getPriority() );
}
}
}
public Mythread2(String name) {
super(name);
}
}
方式二：实现Runnable接口
创建方式
- 创建一个实现了Runnable接口的类
- 实现类去实现Runnable中的抽象方法：run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
- 通过Thread类的对象调用start()
public class RunnableTest {
public static void main(String[] args) {
Five pig = new Five();
Thread m1 = new Thread(pig);
Thread m2 = new Thread(pig);
Thread m3 = new Thread(pig);
m1.setName("窗口一");
m2.setName("窗口二");
m3.setName("窗口三");
m1.start();
m2.start();
m3.start();
}
}
class Five implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":" + ticket);
ticket--;
}
}
}
Thread和Runnable方式的对比
-
联系：public class Thread implements Runnable
-
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
-
对比：
开发中：优先选择实现Runnable接口的方式
原因：
-
实现的方式没有类的单继承性的局限性
比如继承thread,如果这样的话，你就不能继承其他父类，这样使用起来不方便。
而接口可以多继承。
-
实现的方式更适合来处理多个线程有共享数据的情况
因为多个线程来用一个接口的对象，里面的变量不需要声明为static就可以在多个线程之间共享。
-
方式三：实现Callable接口
- 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大
- call()可以有返回值的。
- call()可以抛出异常，被外面的操作捕获，获取异常的信息
- Callable是支持泛型的
创建方式
-
创建一个实现Callable的实现类
-
实现call方法，将此线程需要执行的操作声明在call()中
-
创建Callable接口实现类的对象
-
将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
-
将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
-
获取Callable中call方法的返回值
get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
例子：打印100以内的偶数，并计算其和
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class lizi {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
方法四:线程池的创建
- 好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止
- 创建流程
- 这方面先不深究，需要具体用时在细看
模板代码
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
class NumberThread implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i <= 100;i++){
if(i % 2 != 0){
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class 例子 {
public static void main(String[] args) {
//1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
//设置线程池的属性
// System.out.println(service.getClass());
// service1.setCorePoolSize(15);
// service1.setKeepAliveTime();
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}
线程的生命周期
- 线程的状态
- 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- **就绪：**处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- **运行：**当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
- **阻塞：**在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- **死亡：**线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Lla0pD1-1617205748874)(多线程.assets/image-20210330195333136.png)]
线程的同步
线程同步的意义
例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式
-
问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
-
问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
-
如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。
-
在Java中，我们通过同步机制，来解决线程的安全问题
方式一：同步代码块
-
格式
synchronized(同步监视器){ //需要同步的代码块 } -
说明：
-
操作共享数据的代码，即为需要被同步的代码
注意： -->不能包含代码多了，也不能包含代码少了。
如果少了，可能会出现同步错误问题。
如果多了，虽然安全，但可能会造成逻辑上的错误，多线程处理问题变成单线程处理问题。
-
共享数据：多个线程共同操作的变量。比如：下文程序中的ticket.
-
同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。
注：在实现Runnable接口创建多线程的方式中，我们以考虑使用this充当同步监视器。
-
代码：
Thread的代码块同步
Thread的锁可以用自己本身的类.class，因为类只会加载一次，具有唯一性
package 同步测试;
public class Thread代码块Test {
public static void main(String[] args) {
Five2 m1 = new Five2();
Five2 m2 = new Five2();
Five2 m3 = new Five2();
m1.setName("窗口一");
m2.setName("窗口二");
m3.setName("窗口三");
m1.start();
m2.start();
m3.start();
}
}
class Five2 extends Thread {
private static int ticket = 100;
@Override
public void run() {
while (true) {
synchronized(Five2.class){ //同步器可以用自己本身的类.class，因为类只会加载一次，具有唯一性
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":" + ticket);
ticket--;
} else break;
}
}
}
}
如果换成runable接口，则只需
synchronized(this)
因为创建一个接口对象，可以被不同线程实现。
方式二：同步方法
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
Thread的同步方法
注意：如果Thread的同步方法，则同步方法要声明为staticprivate static synchronized void show().这样的话，这个方法的监视器就会是默认的当前类.class。
如果不加static，监视器则会是this,既new出的对象。
class Window4 extends Thread {
private static int ticket = 100;
@Override
public void run() {
while (true) {
show();
}
}
private static synchronized void show(){//同步监视器：Window4.class
//private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
ticket--;
}
}
}
public class WindowTest4 {
public static void main(String[] args) {
Window4 t1 = new Window4();
Window4 t2 = new Window4();
Window4 t3 = new Window4();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
Runable接口则简单许多
因为只new出一个对象，同步方法的监视器是this也无所谓。
class Five3 implements Runnable {
private int ticket = 100;
@Override
public void run() {
while(true){
show();
}
}
private synchronized void show() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":" + ticket);
ticket--;
}
}
}
-
同步方法的总结
-
同步方法依然涉及到同步监视器，只是不需要我们显式的声明。
-
非静态的同步方法，同步监视器是：this
静态的同步方法，同步监视器是：当前类本身
-
同步的总结
好处：同步的方式，解决了线程的安全问题。
局限性：操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。
同步机制中的锁及死锁问题
-
锁即上面的同步监视器的通俗叫法
-
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
- 我们使用同步时，要避免出现死锁
代码
因为第一个线程start先锁了s1,在进入s2锁之前睡了一会
第二个线程start先锁了s2,在进入s1锁之前睡了一会
结果两个线程互锁了对方，导致程序无法正常进行。
public class DeadLock { public static void main(String[] args) { StringBuffer s1 = new StringBuffer(); StringBuffer s2 = new StringBuffer(); new Thread(){ @Override public void run() { synchronized (s1){ s1.append("a"); s2.append("1"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s2){ s1.append("b"); s2.append("2"); System.out.println(s1); System.out.println(s2); } } } }.start(); new Thread(new Runnable() { @Override public void run() { synchronized (s2){ s1.append("c"); s2.append("3"); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (s1){ s1.append("d"); s2.append("4"); System.out.println(s1); System.out.println(s2); } } } }).start(); } }
方法三：Lock锁—JDK5.0新增
-
synchronized 与 Lock的异同
相同：二者都可以解决线程安全问题
不同：
-
synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
-
Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）
-
-
建议使用顺序：
lock ->同步代码块（已经进入了方法体，分配了相应资源） ->同步方法（在方法体之外）
- 创建方法：
- 实例化ReentrantLock
- 调用锁定方法lock()
- 调用解锁方法：unlock
代码
对于lock来说，他本身的锁也即监视器是它本身，若是用thread继承的方式，记得实例化Reentrantlock的时候把它声明为静态的。
而且在实例化Reentrantlock时，他有一个boolean的构造器，如果里面是true，就是公平为true，让使用这个锁的几个线程一人一次，非常公平，如果不声明，则默认为false，cpu随机分配。
private static ReentrantLock lock = new ReentrantLock(true); //创建实例
import java.util.concurrent.locks.ReentrantLock;
public class ThreadLockTest {
public static void main(String[] args) {
Five6 m1 = new Five6();
Five6 m2 = new Five6();
Five6 m3 = new Five6();
m1.setName("窗口一");
m2.setName("窗口二");
m3.setName("窗口三");
m1.start();
m2.start();
m3.start();
}
}
class Five6 extends Thread {
private static int ticket = 100;
private static ReentrantLock lock = new ReentrantLock(); //创建实例
@Override
public void run() {
while (true) {
try {
lock.lock(); //锁上，先不让别人进去
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":" + ticket);
ticket--;
} else break;
} finally {
lock.unlock(); //解锁
}
}
}
}
- 例题：
银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
代码：
import java.util.concurrent.locks.ReentrantLock;
public class BankDepositTest extends Thread{
public static void main(String[] args) {
Count p1 = new Count();
Customer c1 = new Customer(p1);
Thread m1 = new Thread(c1);
Thread m2 = new Thread(c1);
m1.setName("顾客一");
m2.setName("顾客二");
m1.start();
m2.start();
}
}
class Count{ //账户
public int money;
public void deposit(int num) { 存钱操作
money += num;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":已存入1000，现在余额为："+ money);
}
}
class Customer implements Runnable{
private Count c = new Count();
private String name;
private ReentrantLock lock = new ReentrantLock(true); //定义的锁
public Customer(Count c) {
this.c = c;
}
public void setName(String name) {
this.name = name;
}
@Override
public void run() { //run方法
for (int i = 0; i < 3; i++) {
try {
lock.lock();
c.deposit(1000);
} finally {
lock.unlock();
}
}
}
}
线程的通信
wait,notify,notifyAll
-
意义
- wait():一旦执行此方法，当前线程就会进入阻塞状态，并释放同步监视器
- notify一旦执行:方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
- notifyAll():一旦执行此方法，就会唤醒所有被wait的线程
-
说明
- wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
- wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现IllegalMonitorStateException异常.
- wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。
-
sleep() 和 wait()的异同
- 相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
- 不同点：
- l两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait().
- 调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中.
- 关于是否同步释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印
public class ConTest {
public static void main(String[] args) {
Number n1 = new Number();
Number n2 = new Number();
n1.setName("一号");
n2.setName("二号");
n1.start();
n2.start();
}
}
class Number extends Thread {
private static int num = 1;
@Override
public void run() {
synchronized (Number.class) {//监视器
while (true) {
Number.class.notify();//notify必须是监视器类调
if (num <= 100) {
System.out.println(Thread.currentThread().getName() + ": " + num);
num++;
try {
Number.class.wait();//wait必须是监视器类调
} catch (InterruptedException e) {
e.printStackTrace();
}
} else break;
}
}
}
}
经典例题
-
经典例题：生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
package 经典例题消费者生产者;
public class ProduerAndCustomerTest {
public static void main(String[] args) {
Clerk c = new Clerk();
Productor p = new Productor(c);
Customer cu1 = new Customer(c);
Customer cu2 = new Customer(c);
p.setName("生产者");
cu1.setName("消费者1号");
cu2.setName("消费者2号");
p.start();
cu1.start();
cu2.start();
}
}
class Clerk {
public int goods; //货物的数量
public void producter(){ //控制生产面包
synchronized (Clerk.class){
Clerk.class.notifyAll(); //先释放等待的线程
if(goods < 20){
goods++;
System.out.println(Thread.currentThread().getName() + ":我正在生产第"+goods+"个面包");
}else{
System.out.println("行不行啊，哥都把仓库做满了");
try {//如果满了，就先让这个线程等待一下
Clerk.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void buy(){//控制顾客购买面包
synchronized (Clerk.class){
Clerk.class.notifyAll();//先把线程释放一下
if(goods > 1){
System.out.println(Thread.currentThread().getName() + ":我买了第"+goods+"个面包");
goods--;
}else{
System.out.println("面包被哥买完了");
try {//如果满了，就先让这个线程等待一下
Clerk.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class Productor extends Thread{
private Clerk cl = new Clerk();
public Productor(Clerk cl){
this.cl = cl;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(100);//控制生产面包的时间
} catch (InterruptedException e) {
e.printStackTrace();
}
cl.producter();//开始生产面包
}
}
}
class Customer extends Thread{
private Clerk cl = new Clerk();
public Customer(Clerk cl){
this.cl = cl;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(300);//控制买面包的时间
} catch (InterruptedException e) {
e.printStackTrace();
}
cl.buy();//开始买面包
}
}
}
扫一扫
5229
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
