Day23练习

Hello World️

已于 2022-08-02 17:48:15 修改

阅读量110

点赞数

分类专栏： javaSE 文章标签： java 开发语言

于 2022-06-17 18:15:36 首次发布

本文链接：https://blog.csdn.net/m0_51318597/article/details/125338313

版权

javaSE 专栏收录该内容

59 篇文章 1 订阅

订阅专栏

本文详细介绍了Java中的线程相关方法，包括`run()`、`start()`、`setDaemon()`、`interrupt()`等，阐述了进程与线程的概念，以及多线程的意义。此外，还讲解了线程的创建方式、线程安全问题及其解决方案，同步机制的优缺点，并通过代码示例展示了线程的执行流程和可能遇到的问题。最后，提供了两个编程题，一个是模拟多窗口售票系统，另一个涉及死锁问题的代码展示。

摘要由CSDN通过智能技术生成

文章目录

A:简答题

1、请把我们讲解过的所有类中的方法在API中找到，并使用自己的话进行描述

Thread
public void run()
重写方法 
封装被线程执行的代码
public void start()
启动线程
public final void setDaemon(Daemon(boolean on)
守护线程
该方法必须在启动线程前调用
public final void stop()
停止线程运行
public void interrupt() 
中断线程
public final void join() 
加入线程
等待该线程执行完毕了以后,其他线程才能再次执行
注意事项:在线程启动之后,在调用方法
public final int getPriority() 
获取线程的优先级 
public final void setPriority(int newPriority) 
设置线程的优先级 范围是1---10 默认优先级是5
public static void sleep(long millis) 
线程休眠(毫秒值)
public static void yield()
礼让线程
暂停当前正在执行的线程对象 并执行其他线程

2、请说说什么是进程？什么是线程？多线程有什么意义呢？

进程是一个应用程序
线程是一个进程中的子集(执行单元)
多线程提高CPU的利用率 更好地利用系统资源

3、请写出创建线程的两种方式

方式一:继承Thread
	public class Test01 {
        public static void main(String[] args) {
            //创建线程对象
            Thread thread = new Thread();
            //启动线程
            thread.start();
        }
    }
    //定义线程类 继承Thread
    class AAA extends Thread{
        //重写run()方法
        @Override
        public void run() { }
    }
    
方式二:实现Runnable
    public class Test01 {
        public static void main(String[] args) {
            //创建线程对象
            AAA aaa = new AAA();
            Thread thread = new Thread(aaa);
            //启动线程
            thread.start();
        }
    }
    //实现Runnable
    class AAA implements Runnable{
    	//重写run()方法
        @Override
        public void run() { }
    }

4、请说说启动一个线程是用run()还是 start()?

start()

5、请说说线程安全问题是什么？出现问题后，如何解决？

安全问题  
    a:是否是多线程环境
    b:是否存在共享数据
    c:是否存在多条语句同时操作共享数据   
问题解决
	一个线程执行run()的时候,其他线程不能进行执行
	使用同步代码块
	synchronized(任意对象锁) { 
		同步代码;
	}

6、请说说使用同步机制的好处与弊端？

同步的好处:同步的出现解决了多线程的安全问题。
同步的弊端:当线程相当多时 因为每个线程都会去判断同步上的锁 这是很耗费资源的 无形中会降低程序的运行效率

B:看程序写结果(写出自己的分析理由)，程序填空，改错，看程序写结果。

1、请在指定位置插入代码实现打印输出1-99。

class Test {
    public int start = 1;
    public int end = 99;

    public static void main(String[] args) {
        new Test().method();
    }

    public void method() {
        //插入代码处

        //插入开始
        //使用匿名内部类
        class A extends Thread{
            @Override
            public void run() {
                for (int i = start; i <= end; i++) {
                    System.out.println(i);
                }
            }
        }
        A a = new A();
        //插入结束

        Thread t = new Thread(a);
        t.start();
    }
}

2、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因

class Test implements Runnable {
    public static void main(String[] args) {
        Thread t = new Thread(new Test());
        t.start();
    }

    //重写run()中不能含有参数
    public void run(int num) {
        for (int i = 0; i < num; i++) {
            System.out.println(i);
        }
    }
}

3、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因

class Test extends Thread {
    public static void main(String[] args) {
        Test t1 = new Test();
        Test t2 = new Test();
        t1.start();
        t2.start();
    }
    public void run() {
        System.out.println("1");
        yield();
        System.out.println("2");
    }
}
/*
1 1 2 2
yield()会礼让其他线程执行
*/

4、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因

class Test {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.displayOutput("t has ben created");
        t.start();
    }
}

class MyThread extends Thread {
    public void run() {
        displayOutput("t is run");
    }

    public void displayOutput(String s) {
        System.out.println(s);
    }
}
/*
多态形式
如果需要调用displayOutput()方法 需要向下转型
((MyThread) t).displayOutput("t has ben created");
t has ben created
t is run
*/

5、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因

class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");
        t1.start();
        t2.start();
    }
}

class MyThread extends Thread {
    public MyThread(String s) {
        super(s);
    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                sleep(1000);
            } catch (Exception e) {
            }
            System.out.println(getName());
        }
    }
}
/*
输出 t1 t2各10次
*/

C:编程题

1、编写程序，完成多个窗口共卖100张票的程序，并测试

public class SellTicketsTest {
    public static void main(String[] args) {
        //创建线程对象
        SellTickets s1 = new SellTickets();
        s1.setName("前台1");
        SellTickets s2 = new SellTickets();
        s2.setName("前台2");
        SellTickets s3 = new SellTickets();
        s3.setName("前台3");

        //开启线程
        s1.start();
        s2.start();
        s3.start();
    }
}

class SellTickets extends Thread {
    static int tickets = 100;
    static Object object = new Object();


    @Override
    public void run() {

        while (true) {
            //同步代码块
            synchronized (object) {
                if (tickets < 0) {
                    System.out.println("卖票结束");
                    break;
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在卖票 还剩" + (tickets--) + "张票");
            }

        }
    }
}

2、请写出一段死锁代码

public class DeadLockTest {
    public static void main(String[] args) {
        //创建线程对象
        DeadLock deadLock1 = new DeadLock(true);
        deadLock1.setName("线程A");
        DeadLock deadLock2 = new DeadLock(false);
        deadLock2.setName("线程B");
        //启动线程
        deadLock1.start();
        deadLock2.start();
    }
}

class DeadLock extends Thread {
    static Object objA = new Object();
    static Object objB = new Object();
    boolean flag;

    public DeadLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {

        if (flag) {
            synchronized (objA) {
                System.out.println(Thread.currentThread().getName() + " true--objA");
                synchronized (objB) {
                    System.out.println(Thread.currentThread().getName() + " true--objB");
                }
            }
        } else {
            synchronized (objB) {
                System.out.println(Thread.currentThread().getName() + " false--objB");
                synchronized (objA) {
                    System.out.println(Thread.currentThread().getName() + " false--objA");
                }
            }
        }
        
    }
}