java多线程-基础知识

最新推荐文章于 2024-07-22 14:15:06 发布

Xibo_Yue

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量101

点赞数

分类专栏： java 文章标签：队列多线程 java 并发编程

本文链接：https://blog.csdn.net/loveyuexibo/article/details/107630456

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1. 启动线程的方式

1. 继承Thread类，新建一个当前类对象，并且运行其start()方法

2. 实现Runnable接口，然后新建当前类对象，接着新建Thread对象时把当前类对象传进去，最后运行Thread对象的start()方法

3. 实现Callable接口，新建当前类对象，在新建FutureTask类对象时传入当前类对象，接着新建Thread类对象时传入FutureTask类对象，最后运行Thread对象的start()方法

（FutureTask类是Runnable接口的继承接口的实现类），本质上等于第二种方法

2.线程的状态

Java中线程的状态分为6种：

1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。

线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

3. 阻塞(BLOCKED)：表示线程阻塞于锁。

4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。

5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。

6. 终止(TERMINATED)：表示该线程已经执行完毕。

阻塞状态和等待状态的区别

两者都表示线程当前暂停执行的状态，而两者的区别，基本可以理解为：进入 waiting 状态是线程主动的，而进入 blocked 状态是被动的。更进一步的说，进入 blocked 状态是在同步（synchronized）代码之外，而进入 waiting 状态是在同步代码之内（然后马上退出同步）。

3.线程安全问题----死锁

3.1什么是死锁

死锁发生在当两个或多个线程一直在等待另一个线程持有的锁或资源的时候。这会导致一个程序可能会被拖垮或者直接挂掉，因为线程们都不能继续工作了

3.2死锁举例

在这个例子中，我们创建两个线程，T1和T2。线程T1调用operation1，线程T2调用operation2。

为了完成操作，线程T1需要先获取到lock1再获取到lock2，然后此时线程T2需要先获取到lock2再获取到lock1。因此两个线程都在以相反的顺序获取锁。

public class DeadlockExample {
 
    private Lock lock1 = new ReentrantLock(true);
    private Lock lock2 = new ReentrantLock(true);
 
    public static void main(String[] args) {
        DeadlockExample deadlock = new DeadlockExample();
        new Thread(deadlock::operation1, "T1").start();
        new Thread(deadlock::operation2, "T2").start();
    }
 
    public void operation1() {
        lock1.lock();
        print("lock1 acquired, waiting to acquire lock2.");
        sleep(50);
 
        lock2.lock();
        print("lock2 acquired");
 
        print("executing first operation.");
 
        lock2.unlock();
        lock1.unlock();
    }
 
    public void operation2() {
        lock2.lock();
        print("lock2 acquired, waiting to acquire lock1.");
        sleep(50);
 
        lock1.lock();
        print("lock1 acquired");
 
        print("executing second operation.");
 
        lock1.unlock();
        lock2.unlock();
    }
 
    // helper methods 
}

输出

Thread T1: lock1 acquired, waiting to acquire lock2.
Thread T2: lock2 acquired, waiting to acquire lock1.

一运行这个例子我们就能看到程序导致了一个死锁且永远也退出不了。输出日志展示了线程T1在等待lock2，但lock2被线程T2所持有。相似的，线程T2在等待lock1，他被T1所持有。

3.3避免死锁

死锁在Java中是个很常见的并发问题，因为我们应该设计一个程序来避免潜在的死锁条件。

首先我们应该避免一个线程获取多个锁。
其次如果一个线程真的需要多个锁，我们应该确保所有线程都以相同的顺序获取锁，来避免获取锁时的循环依赖问题。
我们也可以使用带有超时功能的锁，像Lock接口中的tryLock方法，来确保一个线程如果获取不到锁不会一直阻塞。

4.线程安全问题----活锁

4.1什么是活锁

活锁是另一个并发问题，它和死锁很相似。在活锁中，两个或多个线程彼此间一直在转移状态，而不像我们上个例子中互相等待。结果就是所有线程都不能执行它们各自的任务。

4.2活锁举例

现在我们展示一下活锁的情况，我们同样拿上面死锁的例子来解释。线程T1调用operation1，线程T2调用operation2，但是我们稍微改变的操作的逻辑。

两个线程都需要拿到两把锁来完成工作，每个线程拿到第一个锁后都会发现拿不到第二把锁，因此为了让另一个线程先完成任务，每个线程都会释放第一把锁并会尝试再次获取到两把锁。

我们来看下下面的测试例子

public class LivelockExample {
 
    private Lock lock1 = new ReentrantLock(true);
    private Lock lock2 = new ReentrantLock(true);
 
    public static void main(String[] args) {
        LivelockExample livelock = new LivelockExample();
        new Thread(livelock::operation1, "T1").start();
        new Thread(livelock::operation2, "T2").start();
    }
 
    public void operation1() {
        while (true) {
            tryLock(lock1, 50);
            print("lock1 acquired, trying to acquire lock2.");
            sleep(50);
 
            if (tryLock(lock2)) {
                print("lock2 acquired.");
            } else {
                print("cannot acquire lock2, releasing lock1.");
                lock1.unlock();
                continue;
            }
 
            print("executing first operation.");
            break;
        }
        lock2.unlock();
        lock1.unlock();
    }
 
    public void operation2() {
        while (true) {
            tryLock(lock2, 50);
            print("lock2 acquired, trying to acquire lock1.");
            sleep(50);
 
            if (tryLock(lock1)) {
                print("lock1 acquired.");
            } else {
                print("cannot acquire lock1, releasing lock2.");
                lock2.unlock();
                continue;
            }
 
            print("executing second operation.");
            break;
        }
        lock1.unlock();
        lock2.unlock();
    }
 
    // helper methods
}

运行结果

Thread T1: lock1 acquired, trying to acquire lock2.
Thread T2: lock2 acquired, trying to acquire lock1.
Thread T1: cannot acquire lock2, releasing lock1.
Thread T2: cannot acquire lock1, releasing lock2.
Thread T2: lock2 acquired, trying to acquire lock1.
Thread T1: lock1 acquired, trying to acquire lock2.
Thread T1: cannot acquire lock2, releasing lock1.
Thread T1: lock1 acquired, trying to acquire lock2.
Thread T2: cannot acquire lock1, releasing lock2.

4.3避免活锁

避免活锁我们得观察一下活锁发生的条件并根据情况提出方案，比如：

如果我们有两个线程在重复的获取锁和释放锁导致了活锁，我们可以修改下代码让两个线程以一个随机的时间间隔来获取锁，这样线程就有机会获取到它们需要的锁了。
另一个方式来解决我们前面提到的消息队列的问题就是把失败的消息放到单独的的队列中去进一步处理而不是再次放入原队列中。（这个在实际开发中还真遇到过，开发的时候漏掉了一个情况，导致循环消费多条错误消息，队列消息大量积压，要不是队列报警，险些造成线上bug，所以生产环境的队列消费最好还是设置个失败次数加上死信队列，不然出问题可真受不了。）

5.线程安全问题----线程饥饿

低优先级的线程，总是拿不到执行时间

Xibo_Yue

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java多线程-基础知识

1. 启动线程的方式1. 继承Thread类，新建一个当前类对象，并且运行其start()方法2. 实现Runnable接口，然后新建当前类对象，接着新建Thread对象时把当前类对象传进去，最后运行Thread对象的start()方法3. 实现Callable接口，新建当前类对象，在新建FutureTask类对象时传入当前类对象，接着新建Thread类对象时传入FutureTask类对象，最后运行Thread对象的start()方法（FutureTask类是Runnable接口的继承接口的
复制链接

扫一扫

专栏目录