Java 线程的具体介绍

最新推荐文章于 2024-07-27 13:31:57 发布

风继续吹.-

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量706

点赞数 11

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_61898915/article/details/139596763

版权

JavaSE线程的知识可以归纳为以下几个方面：

一、线程的基本概念

线程：线程是CPU调度和分派的基本单位，它可与同属一个进程的其他线程共享进程所拥有的全部资源。线程是独立的执行路径，在程序运行时，即使没有手动创建线程，后台也会有多个线程，如主线程和垃圾回收线程。
进程：进程是执行程序的一次执行过程，是一个动态的概念，是系统资源分配的单位。一个进程中可以包含多个线程。

二、线程的优点

提高程序执行效率：多个任务可以在不同的线程中同时执行，从而提高了CPU的利用率。
改善程序结构：可以将复杂的任务拆分成若干个小任务，由不同的线程来执行，提高代码的分离性和维护性。

三、线程的缺点

资源占用：线程也是程序，线程越多，占用的内存也越多，CPU开销变大。
数据冲突：线程之间同时对共享资源的访问会相互影响，若不加以控制会导致数据出错。

四、线程的创建方式

1.继承Thread类

通过定义线程类继承Thread类，并重写run()方法来实现线程的创建。下面是一个示例，演示如何通过继承Thread类来创建线程：

public class MyThread extends Thread {
    private String name;
    
    public MyThread(String name) {
        super();
        this.name = name;
    }
    
    @Override
    public void run() {
        System.out.println("Thread " + name + " started");
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread " + name + ": " + i);
        }
        System.out.println("Thread " + name + " finished");
    }
    
    public static void main(String[] args) {
        // 创建两个线程对象
        MyThread thread1 = new MyThread("Thread 1");
        MyThread thread2 = new MyThread("Thread 2");
        
        // 启动线程
        thread1.start();
        thread2.start();
        
        try {
            // 等待线程结束
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("All threads finished");
    }
}

在这个例子中，定义了一个继承Thread类的线程类MyThread。在MyThread类中，重写了run()方法，定义了线程的执行逻辑。在这个例子中，线程会打印一些信息，并循环打印数字。

然后，在主线程中创建了两个MyThread对象，并通过调用start()方法启动这两个线程。

最后，通过调用join()方法等待这两个线程执行完成，然后打印"All threads finished"。

这样，我们就通过继承Thread类，并重写run()方法，实现了线程的创建和执行。

2.实现Runnable接口

通过定义任务类实现Runnable接口，并重写run()方法来实现线程的创建。这种方式避免了单继承的局限性，使用更加灵活，并且更适合处理多线程共享资源的情况。下面是一个示例，演示如何通过实现Runnable接口来创建线程：

public class MyRunnable implements Runnable {
    private String name;
    
    public MyRunnable(String name) {
        this.name = name;
    }
    
    @Override
    public void run() {
        System.out.println("Thread " + name + " started");
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread " + name + ": " + i);
        }
        System.out.println("Thread " + name + " finished");
    }
    
    public static void main(String[] args) {
        // 创建两个任务对象
        MyRunnable runnable1 = new MyRunnable("Thread 1");
        MyRunnable runnable2 = new MyRunnable("Thread 2");
        
        // 创建两个线程对象，将任务对象作为构造参数传入
        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("All threads finished");
    }
}

在这个例子中，定义了一个实现Runnable接口的任务类MyRunnable。在MyRunnable类中，实现了Runnable接口并重写了run()方法，定义了线程的执行逻辑。

然后，在主线程中创建了两个MyRunnable对象，并将它们作为参数传入了Thread类的构造方法中，创建了两个线程对象。

最后，通过调用start()方法启动这两个线程，然后再调用join()方法等待线程执行完成。

通过实现Runnable接口，我们避免了单继承的局限性，可以更加灵活地复用代码，并且更适合处理多线程共享资源的情况。每个线程对象都可以共享同一个任务对象，从而实现资源的共享与协作。

3.实现Callable接口

（未在参考文章中明确提及，但为Java中多线程的另一种常见创建方式）Callable接口是Java 5中新增的一个接口，与Runnable接口相似，但Callable接口中的call()方法可以返回执行结果，并且可以抛出异常。
对不起，我之前的回答有误。实际上，Callable接口是另一种创建线程的方式，它与Runnable接口类似，但可以返回结果并抛出异常。下面是一个使用Callable接口创建线程的示例：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable<Integer> {
    private String name;
    
    public MyCallable(String name) {
        this.name = name;
    }
    
    @Override
    public Integer call() throws Exception {
        System.out.println("Thread " + name + " started");
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += i;
        }
        Thread.sleep(2000); // 模拟耗时操作
        System.out.println("Thread " + name + " finished");
        return sum;
    }
    
    public static void main(String[] args) {
        // 创建任务对象
        Callable<Integer> callable = new MyCallable("Thread 1");
        
        // 创建FutureTask对象
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        
        // 创建线程对象
        Thread thread = new Thread(futureTask);
        
        // 启动线程
        thread.start();
        
        try {
            // 获取线程执行结果
            int result = futureTask.get();
            System.out.println("Thread result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        
        System.out.println("All threads finished");
    }
}

在这个例子中，定义了一个实现Callable接口的任务类MyCallable。在MyCallable类中，实现了Callable接口并重写了call()方法，定义了线程的执行逻辑，并返回了计算结果。

然后，在主线程中，创建了一个MyCallable对象作为参数传入FutureTask的构造方法，创建了一个FutureTask对象。

最后，创建了一个线程对象，将FutureTask对象作为参数传入，并启动线程。通过调用get()方法获取线程执行的结果。

使用Callable接口创建线程比起实现Runnable接口，可以更方便地获取线程的返回结果，并对异常进行处理。

五、线程的生命周期

在Java语言中，线程的生命周期包括新建、就绪、运行、阻塞和死亡五个状态，线程在不同状态之间转换以实现其执行过程。下面是对每个状态的详细说明和示例：

新建状态（New）：当创建一个线程对象时，线程进入新建状态。此时线程还没有启动，不会执行任何代码。
```
Thread thread = new Thread();
```
就绪状态（Runnable）：当调用线程对象的start()方法后，线程进入就绪状态。此时线程已经准备好执行，但还没有得到CPU的时间片来执行。
```
Thread thread = new Thread() {
    public void run() {
        // 线程要执行的代码
    }
};
thread.start();
```

运行状态（Running）：当线程得到CPU时间片，开始执行线程的代码时，线程进入运行状态。

Thread thread = new Thread() {
    public void run() {
        System.out.println("Thread is running");
    }
};
thread.start();

阻塞状态（Blocked）：线程在执行过程中，可能会被阻塞，进入阻塞状态。当线程调用sleep()、wait()、join()方法时，或被其他线程调用了相应的方法，线程进入阻塞状态。
当线程调用sleep()、wait()、join()方法时，或被其他线程调用了相应的方法时，线程会进入阻塞状态。下面是Java语言中使用这些方法来实现线程阻塞的示例：

sleep()方法：使当前线程休眠指定的时间（以毫秒为单位）。在休眠期间，线程处于阻塞状态。

Thread thread = new Thread() {
    public void run() {
        try {
            Thread.sleep(2000); // 线程休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread has woken up");
    }
};

thread.start();

wait()方法：使当前线程进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒该线程。

Object lock = new Object();

Thread thread1 = new Thread() {
    public void run() {
        synchronized (lock) {
            try {
                lock.wait(); // 线程进入等待状态，等待其他线程唤醒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread has been notified");
        }
    }
};

Thread thread2 = new Thread() {
    public void run() {
        synchronized (lock) {
            lock.notify(); // 唤醒等待的线程
        }
    }
};

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

join()方法：使当前线程等待指定的线程执行完成。在等待期间，当前线程进入阻塞状态。

Thread thread1 = new Thread() {
    public void run() {
        System.out.println("Thread 1 is running");
        try {
            Thread.sleep(2000); // 线程休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread 1 has completed");
    }
};

Thread thread2 = new Thread() {
    public void run() {
        System.out.println("Thread 2 is running");
        try {
            thread1.join(); // 等待thread1执行完成
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread 2 has completed");
    }
};

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

通过调用上述方法，我们可以控制线程的阻塞和唤醒，实现线程之间的协作和同步。

死亡状态（Terminated）：线程在执行完线程的代码后，或者因异常而终止，线程进入死亡状态。

Thread thread = new Thread() {
    public void run() {
        System.out.println("Thread is running");
    }
};

thread.start();
thread.join(); // 等待线程执行完成后，线程进入死亡状态

通过改变线程的状态，我们可以控制线程的执行流程，并在不同状态中进行相应的操作，从而实现多线程的并发执行。

六、线程同步与锁

当多个线程同时访问操作同一个共享的数据时，可能会引起冲突，因此需要引入线程“同步”机制，即各线程间要有先来后到。通过“排队+锁”的方式，在关键的步骤处，多个线程只能一个一个的执行，从而避免数据冲突。一种常见的线程同步机制是使用锁（Lock）。在关键的代码段或方法中，使用锁来保证同一时间只能有一个线程执行，其他线程需要等待。Java中提供了synchronized关键字和ReentrantLock类来实现锁机制。

假设有一个账户类Account，其中包含一个balance成员变量表示账户余额，以及两个方法deposit和withdraw分别用于存款和取款。

public class Account {
    private int balance;

    public Account(int balance) {
        this.balance = balance;
    }

    public void deposit(int amount) {
        balance += amount;
    }

    public void withdraw(int amount) {
        balance -= amount;
    }

    public int getBalance() {
        return balance;
    }
}

现在有两个线程同时对同一个账户进行存款和取款操作：

public class Main {
    public static void main(String[] args) {
        Account account = new Account(1000);

        Thread depositThread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                account.deposit(10);
            }
        });

        Thread withdrawThread = new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                account.withdraw(10);
            }
        });

        depositThread.start();
        withdrawThread.start();

        try {
            depositThread.join();
            withdrawThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Balance: " + account.getBalance());
    }
}

在上述示例中，两个线程同时对同一个账户进行存款和取款操作。由于存款和取款都涉及对账户余额的修改，因此可能会引起数据冲突和竞态条件。

为了保证线程安全，我们可以在Account类的deposit和withdraw方法中使用synchronized关键字来实现线程同步：

public synchronized void deposit(int amount) {
    balance += amount;
}

public synchronized void withdraw(int amount) {
    balance -= amount;
}

这样，当一个线程正在执行deposit或withdraw方法时，其他线程需要等待，确保同一时间只有一个线程可以修改账户余额。这样就避免了数据冲突和不一致的结果，保证了账户余额的正确性。

ReentrantLock（可重入锁）是Java提供的一种同步机制，用于实现线程的互斥访问。与synchronized关键字相比，ReentrantLock提供了更灵活的锁操作。

下面是一个使用ReentrantLock的示例：

import java.util.concurrent.locks.ReentrantLock;

public class Main {
    private static ReentrantLock lock = new ReentrantLock();
    private static int count = 0;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                lock.lock(); // 获取锁
                try {
                    count++;
                } finally {
                    lock.unlock(); // 释放锁
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                lock.lock(); // 获取锁
                try {
                    count--;
                } finally {
                    lock.unlock(); // 释放锁
                }
            }
        });

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

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Count: " + count);
    }
}

在上述示例中，有两个线程分别执行加法和减法操作，它们都对count变量进行操作。为了保证count的正确性，我们使用了ReentrantLock来实现互斥访问。在每个线程执行操作前调用lock()方法获取锁，在操作完成后调用unlock()方法释放锁。

与synchronized关键字相比，ReentrantLock提供了更多的灵活性，例如：

支持公平锁和非公平锁，默认为非公平锁。
支持可重入，允许同一个线程多次获取锁。
支持条件变量，可以使用多个条件来控制线程的等待和唤醒。
支持尝试获取锁和超时获取锁的操作。

需要注意的是，在使用ReentrantLock时需要手动释放锁，否则可能会导致死锁。通常使用try-finally语句块来确保锁的释放。

通过线程同步机制，我们可以确保多个线程按照一定的次序执行共享代码块，从而保证了数据的一致性，并避免了竞态条件和数据冲突。
以上即为JavaSE线程的主要知识点。在实际编程中，还需要注意线程的调度、优先级、礼让等概念，以及如何处理多线程操作共享数据的问题。

风继续吹.-

关注

11
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
Java 线程的具体介绍

通过线程同步机制，我们可以确保多个线程按照一定的次序执行共享代码块，从而保证了数据的一致性，并避免了竞态条件和数据冲突。以上即为JavaSE线程的主要知识点。在实际编程中，还需要注意线程的调度、优先级、礼让等概念，以及如何处理多线程操作共享数据的问题。
复制链接

扫一扫