Java多线程练习题

 题目1

设置4个线程对象，其中两个实现自减操作，两个实现自增操作

 知识点，1.可以利用volatile实现直接对内存操作无需数据备份。2.可以利用synchronized实现同步防止线程出现数据混乱问题。3.通过join函数实现线程之间阻塞保证线程的执行顺序

package Test1401;
//线程自增
class Decrease implements Runnable {
    private volatile int num = 100;
    @Override
    public void run() {
        synchronized (this) {
            while (num > 0) {
                num--;
                System.out.println(num);
            }
        }
    }
}
//线程自减
class Increase implements Runnable {
    private volatile int number = 0;
    @Override
    public void run() {
        synchronized (this) {
            while (number < 100) {
                number++;
                System.out.println(number);
            }
        }
    }
}
public class javaDemo {
    public static void main(String[] args) {
        Decrease d1 = new Decrease();
        Decrease d2 = new Decrease();
        Increase i1 = new Increase();
        Increase i2 = new Increase();

        Thread Thread1 = new Thread(d1);
        Thread Thread2 = new Thread(d2);
        Thread Thread3 = new Thread(i1);
        Thread Thread4 = new Thread(i2);
//        线程启动
        Thread1.start();
        Thread2.start();
        Thread3.start();
        Thread4.start();
//       线程阻塞队列
        try {
        Thread1.join();
        Thread2.join();
        Thread3.join();
        Thread4.join();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

具体来说，join() 方法的作用如下：

1. 等待线程完成：当在一个线程对象上调用 join() 方法时，当前线程会被阻塞，直到被调用的线程执行完毕。换句话说，它会等待被调用的线程执行结束，然后再继续当前线程的执行。

2. 线程同步：join() 方法可以用于线程间的同步。通过在主线程中调用其他线程的 join() 方法，可以确保其他线程先执行完毕，再继续主线程的执行。这样可以避免多个线程之间的并发问题。

3. 获取线程的结果：在某些情况下，我们可能需要等待一个线程执行完毕，并获取其执行的结果。通过使用 join() 方法，可以等待线程执行完毕后，通过线程对象获取其返回值或执行结果。

总结来说，join() 方法的作用是使当前线程等待调用 join() 的线程执行完毕，实现线程的同步和协调。它在多线程编程中非常有用，可以确保线程的执行顺序和结果的正确性。

---

题目2

设计一个生产计算机类与一个搬运计算机类，要求是生产者生产一台计算机就要搬走一台计算机，如果没有新的计算机那么搬运工就要等待新的计算机产出，如果生产出的计算机没有被搬走就要等待搬运者将计算机搬走，最后搬运统计搬运走的电脑个数

 一个典型的生产者消费者问题。需要用到Object线程的停止等待与唤醒 super.wait(); super.notify();

package Test1402;
class Computer{
//    设置标志位
    private int flag = 0;
    private  int id=1;
    private int count = 0;
    
    //模拟生产函数
    public void produce(){
        synchronized (this){
            while (true){
                if (flag == 1){
                    try {
                        super.wait();
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                System.out.println("生产电脑第"+id++);
                count++;
                flag = 1;
                super.notify();
            }
        }
    }
//    模拟搬运函数
    public  void  Carry(){
        synchronized (this){
            while (true){
                if (flag ==0){
                    try {
                        super.wait();
                        Thread.sleep(1000);

                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                System.out.println("搬运电脑"+(id+-1));
                flag = 0;
                super.notify();
            }
        }
    }
}

class Producer implements Runnable{
    Computer computer;

    Producer(Computer computer){
        this.computer = computer;
    }
    @Override
    public void run() {

        computer.produce();
    }
}

class Carryer implements  Runnable{
    Computer computer;
    Carryer(Computer computer){
        this.computer =computer;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        computer.Carry();
    }
}

public class javaDemo {
    public static void main(String[] args) {
        Computer computer = new Computer();
        new Thread(new Producer(computer)).start();
        new Thread(new Carryer(computer)).start();
    }
}

 问：为什么要在Computer类中定义两个线程的方法？

将这两个方法定义在同一个类中有以下几个好处：

1. 代码逻辑清晰：将生产和搬运的相关逻辑封装在同一个类中，更容易理解和维护。

2. 共享同一个对象：生产者和搬运者共享同一个Computer对象，通过对该对象进行加锁并使用wait()和notify()方法进行线程间通信，可以实现生产者和搬运者之间的同步。

3. 简化线程间通信：通过将生产者和搬运者的方法定义在同一个类中，可以直接调用对象的方法来进行线程间的通信，避免了复杂的线程间通信方式。

4. 可扩展性：如果需要增加其他任务或者更多的工作线程，只需在Computer类中添加相应的方法即可，方便灵活地扩展功能。

---

题目3

设计一个竞拍抢答的程序，要求设置3个抢答者（3个线程），而后发出同时抢答的指令，抢答成功则给出提示，抢答失败则也输出抢答失败

 思路：创建一个竞争类,并且通过设置标志位（资源量）来控制抢答成功个数，并且要通过synchronized同步防止三个线程访问出现数据错乱。

package Test1403;
class Qresponse implements Runnable{
    private  int  flag = 1;
    @Override
    public void run() {
//                   倒计时3s开始抢答
        try {
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        synchronized (this){
            if (flag ==1){
                System.out.println(Thread.currentThread().getName()+"抢答成功");
                flag =0;
            }
            else System.out.println(Thread.currentThread().getName()+"抢答失败");
        }
    }
}

public class javaDemo {
    public static void main(String[] args) {
        Qresponse qresponse = new Qresponse();
        new Thread(qresponse,"抢答者1").start();
        new Thread(qresponse,"抢答者2").start();
        new Thread(qresponse,"抢答者3").start();
    }
}

具体的代码逻辑如下：

1. 首先，创建了一个Qresponse对象qresponse。

2. 然后，创建了三个线程，并传入同一个qresponse对象作为参数，同时启动这三个线程。

3. 线程在启动后会进入run()方法。

4. 在run()方法中，首先通过Thread.sleep()方法使线程休眠3秒，模拟倒计时的效果。

5. 在休眠结束后，进入synchronized块中进行抢答判断。如果flag为1，则表示当前线程是第一个抢答成功的线程，输出抢答成功的信息，并将flag置为0。否则，表示已经有线程抢答成功，输出抢答失败的信息。