基于线程、并发的基本概念(详解)

什么是线程和并发？

线程

线程是程序执行的一条路径，每个线程都是独立的，具有自己的栈空间和程序计数器。同一个程序中如果有多个线程，它们可以并发执行，即同时执行，换句话说，多线程可以用来实现程序的并发性。

并发

并发，指的是系统能够同时处理多个任务的能力。例如，多个线程在同时执行不同的任务，或者同一个线程在同时执行多个任务，都是并发的实现方式。

线程的创建和启动

创建线程

在Java中有两种方式来创建线程：

1. 继承Thread类，重写run方法，调用start方法启动线程。

class MyThread extends Thread {
    public void run() {
        System.out.println("Hello, MyThread!");
    }
}

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

1. 实现Runnable接口，重写run方法，创建Thread对象并调用start方法启动线程。

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Hello, MyRunnable!");
    }
}

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

线程的启动

调用线程的start方法可以启动线程，并使其进入就绪状态，等待CPU调度。当CPU调度到该线程时，该线程才会开始执行。

thread.start();

同步和互斥

同步

多个线程访问同一个共享资源时，如果没有合理的同步机制，则会产生竞态条件，导致程序出现错误。同步是为了防止多个线程同时访问一个共享资源引发的问题。

synchronized关键字可以保证同步，被synchronized修饰的代码块，在同一时刻只能被一个线程执行，其他线程需要等待。

class MyRunnable implements Runnable {
    private int count = 0;

    public void run() {
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                count++;
                System.out.println(Thread.currentThread().getName() + ": " + count);
            }
        }
    }
}

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

在上面的例子中，两个线程共享了MyRunnable实例的count变量，并通过synchronized同步块实现了count变量的同步。

互斥

互斥是指同一时刻只能有一个线程访问共享资源。互斥可以通过Java中的Lock接口实现。

class MyRunnable implements Runnable {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void run() {
        lock.lock();
        try {
            for (int i = 0; i < 5; i++) {
                count++;
                System.out.println(Thread.currentThread().getName() + ": " + count);
            }
        } finally {
            lock.unlock();
        }
    }
}

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

在上面的例子中，通过Lock接口实现了count变量的互斥访问，保证了同一时刻只有一个线程能够访问该变量。

总结

总之，线程和并发是Java中非常重要的概念，利用线程和并发，我们可以实现程序的高效并发执行。当然，线程的创建、同步和互斥等方面都需要我们掌握，并充分考虑线程安全的问题，从而写出高效、可靠的多线程程序。