import java.util.ArrayList; class BackCounter implements Runnable{ private int count =100; public int getCount(){ return count; } public void run(){ for(int i=10;i>0;i--){ synchronized (this){ if(count<=10){ break; } count--; } try{ Thread.sleep(10); }catch(InterruptedException e){ } } } } public class Mooc72 { public static void main(String[] args) throws InterruptedException{ ArrayList<Thread>It=new ArrayList<Thread>(); BackCounter bc=new BackCounter(); It.add(new Thread(bc)); It.add(new Thread(bc)); for(Thread th:It){ } for(Thread th:It){ } System.out.println(bc.getCount()); } }，两个for语句中应该补全什么代码，使得输出结果为80

两个for循环中应该加入以下代码：

for(Thread th:It){
    th.start();
}

for(Thread th:It){
    th.join();
}

第一个for循环启动了两个线程，第二个for循环等待这两个线程执行完毕后再继续执行下面的语句，保证了最后输出的count值为80。

相关问题

import java.util.*; class BackCounter implements Runnable{ private int count=100; //r线程共享变量，对它的处理必须用同步机制进行保护 public int getCount() { return count; } //返回变量值 //线程体 public void run() { for (int i = 10; i > 0,i--){//变量值递减10 【1】{//以下代码在处理共享变量，需同步机制保护 if (count <= 0) break; count--; } try { Thread sleep (10); catch(InterruptedException e){ }//模拟延时10毫秒 } }//线程体结束 } public class Main{

这段 Java 代码中存在一些语法错误，我会尽可能地理解您的意图并解释其中的问题。

首先，在 BackCounter 类的 for 循环中，变量 i 的递减表达式应该是 i--，而不是 i-10。

其次，在 for 循环的大括号中，缺少了一个右括号 "}"，应该在代码末尾补上。

接着，在 run() 方法中，对共享变量 count 的处理没有使用同步机制进行保护，可能会导致线程安全问题。应该在 count 变量的读写操作处使用 synchronized 关键字进行同步。

最后，在 Main 类中，缺少了 main 方法的定义，应该在代码末尾添加一个 main 方法。

下面是修正后的代码，可能与您原始的代码略有不同：

import java.util.*;

class BackCounter implements Runnable {
    private int count = 100;

    public synchronized int getCount() {
        return count;
    }

    public void run() {
        for (int i = 10; i > 0; i--) {
            synchronized (this) {
                if (count <= 0)
                    break;
                count--;
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BackCounter counter = new BackCounter();
        Thread thread = new Thread(counter);
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
        }
        System.out.println("Count: " + counter.getCount());
    }
}

这段代码定义了一个 BackCounter 类，它实现了 Runnable 接口，并覆盖了 run() 方法。在 run() 方法中，使用一个 for 循环来递减 count 变量的值，每次递减后让线程睡眠 10 毫秒。在递减 count 变量的时候，使用 synchronized 关键字来保护共享变量，避免出现线程安全问题。

在 Main 类的 main 方法中，创建一个 BackCounter 对象和一个 Thread 对象，并将两者关联起来。然后启动线程并等待线程结束，最后输出 count 变量的值。

import java. util.*; class BackCounter implements Runnable { private int count=100;//线程共享变量,对它的处理必须用同步机制进行保护public int getCount(){ return count; }//返回变量值 //线程体 public void run(){ for (int i=10;i>0;i--){//变量值递减10 【1】{∥以下代码在处理共享变量，需要同步机制保护 if(count <=0) break; count--; } try { Thread. sleep(10); }catch(InterruptedExceptione){ }//模拟延时10毫秒 } }//线程体结束 } public class Main { public static void main(String[]args) throws InterruptedException {∥某些线程方法会抛出检查型异常 ArrayList<Thread>1t=new ArrayList<Thread>(); BackCounter bc=new BackCounter();/创建实现类对象 It. add(new Thread(bc));//创建线程对象 It. add(new Thread(bc)); for (Thread th:It) 【2】;//启动线程 for (Thread th :1t) 【3】;//等待线程结束 System. out. println(bc. getCount()); } } 补充完整

该代码缺少了启动线程和等待线程结束的代码，可以在Main类中添加启动线程和等待线程结束的代码。修改后的代码如下所示：

import java.util.*;

class BackCounter implements Runnable {
    private int count = 100; // 线程共享变量,对它的处理必须用同步机制进行保护

    public int getCount() {
        return count; // 返回变量值
    }

    // 线程体
    public void run() {
        for (int i = 10; i > 0; i--) { // 变量值递减10
            synchronized (this) { // 以下代码在处理共享变量，需要同步机制保护
                if (count <= 0)
                    break;
                count--;
            }
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
            } // 模拟延时10毫秒
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException { // 某些线程方法会抛出检查型异常
        ArrayList<Thread> t = new ArrayList<Thread>();
        BackCounter bc = new BackCounter(); // 创建实现类对象
        t.add(new Thread(bc)); // 创建线程对象
        t.add(new Thread(bc));
        for (Thread th : t) {
            th.start(); // 启动线程
        }
        for (Thread th : t) {
            th.join(); // 等待线程结束
        }
        System.out.println(bc.getCount());
    }
}

这段代码实现了一个计数器，通过两个线程共同对一个同步变量count进行递减，最后输出count的值。在Main类中创建了一个BackCounter对象和两个线程对象，并启动了两个线程，对count进行递减。在最后等待两个线程结束后，输出count的值。需要注意的是，在线程体中对count进行递减的操作需要使用同步机制进行保护，这里使用了synchronized关键字来实现。