使用Java中的线程函数，如何实现多线程编程和同步？

在Java中，可以使用Thread类和Runnable接口来创建线程。可以通过继承Thread类或实现Runnable接口创建线程，并重写run方法来定义线程的执行逻辑。

1. 通过继承Thread类创建线程：

public class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的逻辑
    }
}

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

2. 通过实现Runnable接口创建线程：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的逻辑
    }
}

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

在多线程编程中，可能会存在多个线程同时访问共享资源的情况，这时需要进行线程同步，以避免数据不一致或者出现竞态条件。

Java提供了关键字synchronized来实现线程同步：

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

public class MyRunnable implements Runnable {
    private Counter counter;
    
    public MyRunnable(Counter counter) {
        this.counter = counter;
    }
    
    @Override
    public void run() {
        counter.increment();
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        MyRunnable runnable1 = new MyRunnable(counter);
        MyRunnable runnable2 = new MyRunnable(counter);
        Thread thread1 = new Thread(runnable1);
        Thread thread2 = new Thread(runnable2);
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(counter.getCount()); // 输出结果为2
    }
}

在上述代码中，Counter类中的increment方法和getCount方法都使用了synchronized关键字，保证了多个线程同时访问这两个方法时的线程安全性。

此外，Java中还提供了其他的同步机制，比如Lock、Condition、Semaphore等，可以根据实际需求进行选择和使用。