Java多线程编程

发布时间:2023年12月21日

为什么需要多线程?

在计算机科学领域,多线程是一种并发执行的机制,可以让程序同时执行多个任务。在Java中,多线程编程是非常重要的,它可以提高程序的性能和效率。在单核处理器时代,多线程可以通过在等待I/O时执行其他任务来充分利用CPU资源。而在多核处理器时代,多线程更是成为了发挥硬件性能的关键手段。

Java中的多线程基础

Java中实现多线程主要有两种方式,一种是继承Thread类,另一种是实现Runnable接口。下面分别介绍这两种方式的使用。

继承Thread类

class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getId() + " Value " + i);
        }
    }
}

public class ThreadExample {
    public static void main(String args[]) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
    }
}

在上面的例子中,我们创建了一个继承自Thread类的MyThread类,并重写了run方法。然后在main方法中创建了两个线程对象并分别启动。每个线程执行run方法中的代码,输出当前线程的ID和循环变量的值。

实现Runnable接口

class MyRunnable implements Runnable {
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getId() + " Value " + i);
        }
    }
}

public class RunnableExample {
    public static void main(String args[]) {
        Thread t1 = new Thread(new MyRunnable());
        Thread t2 = new Thread(new MyRunnable());
        t1.start();
        t2.start();
    }
}

在这个例子中,我们创建了一个实现了Runnable接口的MyRunnable类,并同样在main方法中创建了两个线程对象。不同的是,这次我们将MyRunnable的实例作为参数传递给Thread的构造函数,然后启动线程。

同步和锁

多线程编程中最常见的问题之一就是数据同步。当多个线程同时访问共享资源时,可能会导致数据不一致的问题。为了解决这个问题,Java提供了synchronized关键字和Lock接口。

使用synchronized关键字

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

public class SynchronizedExample {
    public static void main(String args[]) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Counter: " + counter.getCount());
    }
}

在上述例子中,我们创建了一个Counter类,其中的increment方法使用synchronized关键字进行同步,保证了对count的操作是原子的。然后在main方法中创建两个线程分别对Counter实例进行1000次增加操作,最后输出计数器的值。

使用Lock接口

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

public class LockExample {
    public static void main(String args[]) throws InterruptedException {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Counter: " + counter.getCount());
    }
}

在这个例子中,我们使用了ReentrantLock实现了Lock接口,通过lockunlock方法手动控制同步区域。同样,在main方法中创建两个线程对Counter实例进行1000次增加操作,最后输出计数器的值。

总结

Java多线程编程是一个广泛使用的技术,它可以提高程序的性能和效率。通过继承Thread类或实现Runnable接口创建线程,以及使用synchronized关键字或Lock接口实现数据同步,我们可以更好地管理和控制多线程程序。在实际应用中,需要根据具体的业务场景选择合适的多线程方案,并注意避免常见的多线程安全问题。

如果你有任何问题、建议或者想要分享自己的经验,欢迎在评论区留言!

?

?

?

?

文章来源:https://blog.csdn.net/m0_73449789/article/details/135115535
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。