java 两个线程同时执行

Java中可以使用多线程来实现两个线程同时执行。以下是一个简单的例子：

public class TwoThreads {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程1要执行的代码
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 线程2要执行的代码
            }
        });

        thread1.start();
        thread2.start();
    }
}

在这个例子中，我们创建了两个线程`thread1`和`thread2`，并分别传入了要执行的代码块。最后，我们调用`start()`方法启动这两个线程。

注意：在多线程编程中，需要注意线程安全问题，避免出现数据竞争等问题。

相关问题

java两个线程交替执行

在Java中，可以使用wait()和notify()方法实现两个线程交替执行。具体实现方法如下：

首先，定义一个共享的对象作为锁：

Object lock = new Object();

然后，定义两个线程类，分别为奇数线程和偶数线程：

class OddThread implements Runnable {
    private Object lock;
    public OddThread(Object lock) {
        this.lock = lock;
    }
    public void run() {
        for (int i = 1; i <= 100; i += 2) {
            synchronized (lock) {
                System.out.println("OddThread: " + i);
                lock.notify();
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class EvenThread implements Runnable {
    private Object lock;
    public EvenThread(Object lock) {
        this.lock = lock;
    }
    public void run() {
        for (int i = 2; i <= 100; i += 2) {
            synchronized (lock) {
                System.out.println("EvenThread: " + i);
                lock.notify();
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在奇数线程中，先输出奇数，然后调用notify()方法通知偶数线程继续执行，再调用wait()方法让自己进入等待状态。在偶数线程中，先输出偶数，然后调用notify()方法通知奇数线程继续执行，再调用wait()方法让自己进入等待状态。

最后，在main函数中创建两个线程对象，并启动它们：

public static void main(String[] args) {
    Object lock = new Object();
    Thread t1 = new Thread(new OddThread(lock));
    Thread t2 = new Thread(new EvenThread(lock));
    t1.start();
    t2.start();
}

这样，就可以实现两个线程交替执行了。

java创建多线程同时执行不同任务

在Java中，创建多线程同时执行不同任务可以使用以下两种方法：

1. 实现Runnable接口

通过实现Runnable接口来创建线程，需要实现run()方法，该方法中定义了线程要执行的任务。然后创建一个Thread对象，将实现了Runnable接口的类的对象作为参数传入，最后调用start()方法启动线程。

示例代码：

class MyRunnable implements Runnable {
    public void run() {
        // 线程要执行的任务
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        thread1.start();
        thread2.start();
    }
}

上述代码中，创建了两个线程thread1和thread2，它们都执行MyRunnable类中定义的任务。

2. 继承Thread类

通过继承Thread类来创建线程，需要重写run()方法，该方法中定义了线程要执行的任务。然后创建一个Thread类的子类的对象，调用start()方法启动线程。

示例代码：

class MyThread extends Thread {
    public void run() {
        // 线程要执行的任务
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        thread1.start();
        thread2.start();
    }
}

上述代码中，创建了两个线程thread1和thread2，它们都执行MyThread类中定义的任务。

无论是哪种方法，都可以创建多个线程同时执行不同任务。