java 定义两个线程类 ThreadA 和 ThreadB，其行为是分别显示“I am Chines”和 “I love our motherland”， 然后在 main()函数中创建两个线程的对象，并 分别启动两个线程。

下面是实现代码：

public class ThreadA extends Thread {
    @Override
    public void run() {
        System.out.println("I am Chinese");
    }
}

public class ThreadB extends Thread {
    @Override
    public void run() {
        System.out.println("I love our motherland");
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();

        threadA.start();
        threadB.start();
    }
}

在上面的代码中，我们定义了两个线程类 ThreadA 和 ThreadB，分别重写了 run() 方法，用于定义线程的行为。在 main() 函数中，我们创建了两个线程对象 threadA 和 threadB，并分别调用它们的 start() 方法来启动线程。由于线程是并发执行的，因此这两个线程会同时运行，分别输出 “I am Chinese” 和 “I love our motherland”。

相关问题

定义两个线程类 ThreadA 和 ThreadB，其行为是分别显示“I am Chines”和 “I love our motherland”， 然后在 main()函数中创建两个线程的对象，并 分别启动两个线程。

以下是使用 C++11 标准线程库实现的代码：

#include <iostream>
#include <thread>

class ThreadA {
public:
    void operator()() {
        std::cout << "I am Chinese" << std::endl;
    }
};

class ThreadB {
public:
    void operator()() {
        std::cout << "I love our motherland" << std::endl;
    }
};

int main() {
    ThreadA a;
    ThreadB b;

    std::thread threadA(a);
    std::thread threadB(b);

    threadA.join();
    threadB.join();

    return 0;
}

在这个程序中，我们定义了两个线程类 `ThreadA` 和 `ThreadB`，它们都重载了调用运算符 `operator()`，分别输出一句话。在 `main` 函数中，我们创建了两个对象 `a` 和 `b`，并将它们传入 `std::thread` 的构造函数中，创建了两个线程对象 `threadA` 和 `threadB`。最后，我们使用 `join` 方法等待两个线程执行完毕，然后退出程序。

java 创建两个线程A和B，两个线程轮流打印数字，从1打印到100。

可以使用一个共享变量来实现两个线程轮流打印数字的功能。具体实现如下：

public class TwoThreadsPrintNumbers {
    private static final int MAX_NUMBER = 100;
    private static volatile int number = 1;
    private static Object lock = new Object();

    public static void main(String[] args) {
        Thread threadA = new Thread(new Runnable() {
            @Override
            public void run() {
                while (number <= MAX_NUMBER) {
                    synchronized (lock) {
                        if (number % 2 == 1) {
                            System.out.println(Thread.currentThread().getName() + ": " + number);
                            number++;
                        }
                    }
                }
            }
        }, "ThreadA");

        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                while (number <= MAX_NUMBER) {
                    synchronized (lock) {
                        if (number % 2 == 0) {
                            System.out.println(Thread.currentThread().getName() + ": " + number);
                            number++;
                        }
                    }
                }
            }
        }, "ThreadB");

        threadA.start();
        threadB.start();
    }
}

在这个代码中，我们使用了一个 `number` 变量来记录当前要打印的数字，同时使用一个 `lock` 对象来保证两个线程的互斥访问。`ThreadA` 和 `ThreadB` 轮流获得 `lock` 对象的锁，然后判断 `number` 是否符合自己的要求（奇数或偶数），如果符合则打印并将 `number` 加一。最后，当 `number` 大于最大值时，两个线程都会退出循环，结束线程的执行。