使用Java线程函数实现多线程和线程同步

使用Java线程函数实现多线程和线程同步可以通过创建Thread对象和实现Runnable接口来实现。

1. 使用Thread类创建多线程：

使用Thread类可以通过继承它，并重写run方法来创建多线程。下面是一个例子：

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();
    }
}

在上面的例子中，我们创建了一个继承自Thread类的子类MyThread，并重写了run方法，在run方法中指定了线程要执行的代码。在main函数中，我们创建了两个MyThread对象，并分别调用start方法来启动线程。

2. 使用实现Runnable接口创建多线程：

另一种创建多线程的方式是实现Runnable接口，在实现类中重写run方法。下面是一个例子：

class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的代码
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread thread1 = new Thread(r);
        Thread thread2 = new Thread(r);
        thread1.start(); // 启动线程
        thread2.start();
    }
}

在上面的例子中，我们创建了一个实现了Runnable接口的类MyRunnable，并重写了run方法，在run方法中指定了线程要执行的代码。在main函数中，我们创建了两个Thread对象，并将MyRunnable对象作为参数传递给Thread的构造函数，然后调用start方法来启动线程。

3. 线程同步：

线程同步是为了保证多个线程对共享资源的安全访问，可以使用synchronized关键字来实现线程同步。下面是一个使用synchronized关键字实现线程同步的例子：

class Counter {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
    public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    counter.increment(); // 递增count
                }
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    counter.increment(); // 递增count
                }
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join(); // 等待线程执行完毕
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(counter.getCount()); // 输出2000
    }
}

在上面的例子中，我们创建了一个Counter类，该类有一个increment方法用来递增count的值，并且使用synchronized关键字修饰。在main函数中，我们创建了两个线程，每个线程执行1000次counter.increment()来递增count的值。然后，我们使用thread1.join()和thread2.join()来等待线程执行完毕，最后输出counter.getCount()的值，应该是2000。

通过上述例子，我们可以看到使用Java线程函数实现多线程和线程同步的基本方法。要注意的是，如果多个线程同时访问和修改同一个共享资源，可能会引起线程安全问题，所以需要使用线程同步来保证共享资源的安全访问。