聊聊java多线程创建方式及线程安全问题

那么让我们来聊聊Java多线程创建方式及线程安全问题的完整攻略。

1. Java多线程的创建方式

Java中创建多线程有两种方式，一种是继承Thread类，另一种是实现Runnable接口。

1.1 继承Thread类

示例代码如下：

class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread is running");
    }
}

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

1.2 实现Runnable接口

示例代码如下：

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("MyRunnable is running");
    }
}

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

通过实现Runnable接口创建线程的好处是我们可以继承其他类，而Java不支持多重继承，这使得我们不能同时继承Thread类以及其他类。此外，Runnable接口使用起来更加灵活，因为我们可以将同一个Runnable实例传递给多个Thread类。

2. 线程安全问题

Java中线程安全问题是指在多个线程同时读写共享资源时，可能会导致数据出错或者程序崩溃的问题。比如，在多个线程同时进行修改一个变量时，可能会导致其中某个线程修改了这个变量的值，而其他线程并没有及时读取最新的变量值，从而导致数据出错。

2.1 同步方法

同步方法是通过在方法声明中添加synchronized关键字来实现的，其作用是保证同一时间只有一个线程可以访问该方法。

示例代码如下：

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

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.decrement();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Counter value: " + counter.value());
    }
}

2.2 同步代码块

同步代码块是指在代码块中添加synchronized关键字来实现的，其作用是保证同一时间只有一个线程可以访问该代码块。

示例代码如下：

class Counter {
    private int count = 0;
    private Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public void decrement() {
        synchronized (lock) {
            count--;
        }
    }

    public int value() {
        synchronized (lock) {
            return count;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.decrement();
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Counter value: " + counter.value());
    }
}

结论

以上就是关于Java多线程创建方式及线程安全问题的详细讲解，其中包含了实现Runnable接口和继承Thread类两种创建方式，以及同步方法和同步代码块两种线程安全的实现方式。需要注意的是，在实现同步方法或同步代码块时需要加锁来保证线程安全，否则会出现不同步的情况。