Java并发

最新推荐文章于 2024-01-09 09:03:23 发布
最新推荐文章于 2024-01-09 09:03:23 发布
阅读量203 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WLiiii/article/details/99698133
版权
1. 线程状态转换

新建（New）
创建后尚未启动
可运行（Runnable）
可能正在运行，也可能正在等待CPU时间片。
包含了操作系统线程状态中的Running和Ready。
阻塞（Blocked）
等待获取一个排它锁，如果其线程释放了锁就会结束次状态。
无限期等待（Waiting）
等待其它线程显式地唤醒，否则不会被分配 CPU 时间片。
在这里插入图片描述
限期等待（Timed Waiting）
无需等待其他线程显示的被唤醒，在一定时间之后会被系统自动唤醒。
调用Thread.sleep()方法使线程进入限期等待状态时，常常用 是一个线程睡眠 进行描述。
调用Object.wait()方法使线程进入限期等待或者无限期等待时，尝尝用挂起一个线程进行描述。
睡眠和挂起是用来描述行为，而阻塞和等待用来描述状态。
阻塞和等待的区别在于，阻塞是被动地，它是在等待获取一个排他锁。而等待时主动地，通过调用Thread.sleep()和Object.wait()等方法进去。
在这里插入图片描述
死亡（Terminated）
可以使线程结束之后自己结束，或者产生了异常而结束。

2. 使用线程

有三种使用线程方法：

  • 实现Runnable接口；
  • 实现Callable接口；
  • 继承Thread类。

实现Runnable和Callable接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还是需要通过Thread来调用。可以说任务是通过线程驱动从而执行的。

实现Runnable接口

需要实现run()方法。
通过Thread调用start()方法来启动线程。

public class MyRunnable implements Runnable {
    public void run() {
		// ... 
	}
}
public static void main(String[] args) {
    MyRunnable instance = new MyRunnable();
    Thread thread = new Thread(instance);
    thread.start();
}
实现Callable接口

与Runnable相比，Callable可以有返回值，返回值通过FutureTask进行封装。

public class MyCallable implements Callable<Integer> {
    public Integer call() {
		return 123; 
	}
}

public static void main(String[] args) throws ExecutionException, 
											InterruptedException {
    MyCallable mc = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(mc);
    Thread thread = new Thread(ft);
    thread.start();
    System.out.println(ft.get());
}
继承Thread类

同样也是需要实现run()方法，因为Thread类也实现了Runnable接口。
当调用start()方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的run()方法。

public class MyThread extends Thread {
    public void run() {
		// ... 
	}
}
public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}
实现接口 VS 继承Thread

实现接口会更好一些，因为：

  • Java不支持多继承，因此继承了Thread类就无法继承其他类，但是可以实现多个接口；
  • 类可能只要求可执行就行，继承整个Thread类开销过大。
3.基础线程机制
Executor

Executor管理多个异步任务的执行，而无需程序员显示的管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要进行同步操作。
主要有三种Executor：

  • CachedThreadPool：一个任务创建一个下次呢很难过；
  • FixedThreadPool：所有任务只能使用固定大小的线程；
  • SingleThreadExecutor：相当于大小为1的FixedThreadPool。
 public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 5; i++) {
        executorService.execute(new MyRunnable());
    }
    executorService.shutdown();
}
Daemon

守护线程是程序运行时在后台提供服务的线程，不属于程序中不可或缺的部分。
当所有非守护线程结束时，程序也就终止，同时会杀掉所有守护线程。
main()属于非守护线程。
使用setDaemon()方法将一个线程设置为守护线程。

 public static void main(String[] args) {
    Thread thread = new Thread(new MyRunnable());
    thread.setDaemon(true);
}
sleep()

Thread.sleet(millisec) 方法会休眠当前正在执行的线程，millisec单位为毫秒。
sleet()可能会抛出InterruptedException，因为一场不能跨线程传播回main()中，因此必须在本地进行处理。线程中抛出的其他异常也同样需要在本地进行处理。

public void run() {
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
yield()

对静态方法Thread.yield()的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其他线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其他线程可以运行。

public void run() {
    Thread.yield();
}
4.中断

一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。

InterruptedException

通过调用一个线程的interrupt()来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出InterruptedException，从而提前结束该线程。但是不能中断I/O阻塞和synchronized锁阻塞。
对于以下代码，在main()中启动一个线程之后再中断它，由于线程中调用了Thread.sleep()方法，因此会抛出一个InterruptedException，从而提前结束线程，不再执行之后的语句。

public class InterruptExample {
    private static class MyThread1 extends Thread {
        @Override
        public void run() {
            try {
            	Thread.sleep(2000);
    			System.out.println("Thread run");
			} catch (InterruptedException e) {
    			e.printStackTrace();
			}
		} 
	}
}

public static void main(String[] args) throws InterruptedException {
    Thread thread1 = new MyThread1();
    thread1.start();
    thread1.interrupt();
    System.out.println("Main run");
}

Main run
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at InterruptExample.lambda$main$0(InterruptExample.java:5)
    at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
    at java.lang.Thread.run(Thread.java:745)
interrupted()

如果一个线程的run()方法执行了一个无限循环，并且没有执行sleep()等会抛出InterruptedException的操作，那么调用线程的interrupt()方法就无法使线程提前结束。
但是调用interrupt()方法会设置线程中断标记，此时调用interrupted()方法会返回true。因此可以在循环体中使用interrupted()方法来判断线程是否处于中断状态，从而提前结束线程。

public class InterruptExample {
    private static class MyThread2 extends Thread {
        @Override
		public void run() {
    		while (!interrupted()) {
			// .. 
			}
		}
    	System.out.println("Thread end");
    	}
    }
}

public static void main(String[] args) throws InterruptedException {
    Thread thread2 = new MyThread2();
    thread2.start();
    thread2.interrupt();
}

Thread end
Executor 的中断操作

调用Executor的shutdown()方法会等待线程都执行完毕之后再关闭，但是如果调用的是shutdownNow()方法，则相当于调用每个线程的interrupt()方法。
以下使用Lambda创建线程，相当于创建了一个匿名内部线程。

public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> {
        try {
            Thread.sleep(2000);
            System.out.println("Thread run");
        } catch (InterruptedException e) {
            e.printStackTrace();
		} });
    executorService.shutdownNow();
    System.out.println("Main run");
}

Main run
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
    at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
    at java.lang.Thread.run(Thread.java:745)

如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future<?> 对 象，通过调用该对象的 cancel(true) 方法就可以中断线程。

5.互斥同步

Java提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是JVM实现的synchronized，另一个是JDK实现的ReentrantLock。

synchronized
  1. 同步一个代码块
public void func() {
    synchronized (this) {
		// ...
	 }
}

它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。
对于以下代码，使用ExecutorService执行了两个线程，由于调用的是同一个对象的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语块时，另一个线程就必须等待。

public class SynchronizedExample {
	public void func1() {
	    synchronized (this) {
	        for (int i = 0; i < 10; i++) {
	            System.out.print(i + " ");
	        }
	    }
	}
}

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e1.func1());
}

01234567890123456789

对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程不需要同步。从输出结果可以看出两个线程交叉执行。

public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func1());
    executorService.execute(() -> e2.func1());
}

00112233445566778899
  1. 同步一个方法
public synchronized void func () {
    // ...
}

他和同步代码块一样，作用于同一个对象。
3. 同步一个类

public void func() {
    synchronized (SynchronizedExample.class) {
		// ... 
	}
}

作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。

 public class SynchronizedExample {
    public void func2() {
        synchronized (SynchronizedExample.class) {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
			}	 
		}
	} 
}

 public static void main(String[] args) {
    SynchronizedExample e1 = new SynchronizedExample();
    SynchronizedExample e2 = new SynchronizedExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> e1.func2());
    executorService.execute(() -> e2.func2());
}

01234567890123456789
  1. 同步一个静态方法
 public synchronized static void fun() {
    // ...
}

作用于整个类。

ReentrantLock

ReentrantLock是java.util.concurrent（J.U.C）包中的锁。

 public class LockExample {
    private Lock lock = new ReentrantLock();
    public void func() {
        lock.lock();
        try {
            for (int i = 0; i < 10; i++) {
                System.out.print(i + " ");
            }
		} finally {
			lock.unlock(); // 确保释放锁，从而避免发生死锁。
		} 
	}
}

public static void main(String[] args) {
    LockExample lockExample = new LockExample();
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(() -> lockExample.func());
    executorService.execute(() -> lockExample.func());
}

01234567890123456789
比较
  1. 锁的实现
    synchronized是jvm实现的，而ReentrantLock是JDK实现的。
  2. 性能
    新版本Java对synchronized进行了很多优化，例如自旋锁等，synchronized与ReentrantLock大致相同。
  3. 等待可中断
    当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
    ReentrantLock可中断，synchronized不行。
  4. 公平锁
    公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
    synchronized中的锁时非公平的，ReentrantLock默认情况下是非公平的，但是也可以是公平的。
  5. 锁绑定多个条件
    一个ReentrantLock可以同时绑定多个Condition对象。
使用选择

除非需要使用ReentrantLock的高级功能，否则优先使用synchronized，因为这是synchronized是JVM实现的一种锁机制，JVM原生的支持他，而ReentrantLock不是所有的JDK版本都支持，并且使用Synchronized不用担心没有释放锁而导致死锁的问题，因为JVM会确保锁的释放。

6.线程之间的协作

当多个线程可以一起工作去解决某个问题时，如果某部分必须在其他部分之前完成，那么就需要对线程进行协调。

join()

在线程中调用另一个线程的join()方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。
对于以下代码，虽然b线程先启动，但是还是因为在b线程中调用了a线程的join()方法，b线程会等待a线程结束才继续执行，因此最后能够保证a线程的输出先于b线程的输出。

public class JoinExample {
    private class A extends Thread {
    	@Override
	    public void run() {
	        System.out.println("A");
	    }
	}
	private class B extends Thread {
	private A a;
	    B(A a) {
	        this.a = a;
	}
    @Override
    public void run() {
        try {
            a.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
		}
        System.out.println("B");
    	}
	}
	public void test() {
	    A a = new A();
		B b = new B(a);
		b.start();
		a.start();
	}
}

public static void main(String[] args) {
    JoinExample example = new JoinExample();
    example.test();
}

 A B
wait() notify() notifyAll()

调用wait()使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用notify()或者notifyAll()来唤醒挂起的线程。
他们都属于Object的一部分，而不是Thread。
只能用在同步方法或者同步控制块中使用，否则会在运行时抛出IIIegalMonitorStateException。
使用wait()挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法进行notify()或者notifyAll()来唤醒挂起线程，造成死锁。

public class WaitNotifyExample {
    public synchronized void before() {
        System.out.println("before");
        notifyAll();
	}
    public synchronized void after() {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("after");
    }
}

public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    WaitNotifyExample example = new WaitNotifyExample();
    executorService.execute(() -> example.after());
    executorService.execute(() -> example.before());
}

 before 
 after
wait()和sleep()的区别
  • wait()是Object的方法，而sleep()是Thread的静态方法；
  • wait()会释放锁，sleep()不会.
await() signal() signalAll()

java.util.concurrent类库中提供了Condition类来实现线程之间的协调，可以在Condition上调用await()方法使线程等待，其他线程调用signal()或signalAll()方法唤醒等待的线程。
相当于wait()这种等待方式，await()可以指定等待的条件。
相比于wait()这种等待方式，await()可以指定等待的条件，因此更加灵活。
使用Lock来获取一个Condition对象

public class AwaitSignalExample {
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	public void before() { 
		lock.lock();
		try { 
			System.out.println("before"); condition.signalAll();
		} finally {
			lock.unlock(); }
	}
	public void after() { lock.lock();
		try {
			condition.await(); 
			System.out.println("after");
		} catch (InterruptedException e) { 
			e.printStackTrace();
		} finally { 
			lock.unlock();
		} 
	}
}

public static void main(String[] args) {
	ExecutorService executorService = Executors.newCachedThreadPool(); 
	AwaitSignalExample example = new AwaitSignalExample(); 
	executorService.execute(() -> example.after()); 
	executorService.execute(() -> example.before());
}
before
after
7.J.U.C - AQS

java.util.concurrent(J.U.C)大大提高了并发性能，AQS 被认为是 J.U.C 的核心。

CountDownLatch

用来控制一个线程等待多个线程。
维护了一个计数器cnt，每次调用countDown()方法会让计数器的值减1，减到0的时候，那些因为调用wait()方法而在等待的线程就会被唤醒。

public class CountdownLatchExample {
	public static void main(String[] args) throws InterruptedException { 
		final int totalThread = 10;
		CountDownLatch countDownLatch = new CountDownLatch(totalThread); 
		ExecutorService executorService = Executors.newCachedThreadPool(); 
		for (int i = 0; i < totalThread; i++) {
			executorService.execute(() -> { 
			System.out.print("run..");
			countDownLatch.countDown();
			}); 
		}
		countDownLatch.await(); 
		System.out.println("end"); 
		executorService.shutdown();
	}
 }
 run..run..run..run..run..run..run..run..run..run..end
WLiiii
关注
java并发编程实践pdf笔记
12-15
Java并发编程实践是Java开发中不可或缺的一个领域，它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点，旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...
Java并发编程实战华章专业开发者书库 (Tim Peierls 等 美Brian Goetz).pdf
04-09
《Java并发编程实战》是一本深入探讨Java平台并发编程的权威指南，由Tim Peierls等人与Brian Goetz合著，旨在帮助Java开发者理解和掌握在多线程环境中编写高效、安全的代码。这本书由拥有丰富经验的JDK并发大师及...
编程必备：JAVA多线程详解
拾一二的博客
06-14 8566
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java基础--多线程详解
a18792721831的博客
06-06 3934
1.线程的概念； 2.线程如何使用； 3.jdk支持的基本线程池； 4.线程生命周期； 5.线程启动与终止； 6.后台线程； 7.线程继承其他类；
一文搞懂Java多线程，讲的很详细，收藏起来慢慢看
兴趣是最好的老师，勤能补拙
07-05 2088
多线程是指在一个程序中同时执行多个线程，每个线程都有自己独立的执行路径。在多线程中，程序的执行可以同时进行多个任务，从而提高系统的资源利用率和响应性能。在传统的单线程编程模型中，程序按照顺序执行，一次只处理一个任务。这种方式在某些情况下可能会导致效率低下或者无法满足需求。而多线程通过将任务拆分为多个子任务，并且在不同的线程上同时执行，从而实现并发处理。
Java多线程
余杯冷饮的博客
04-04 505
子类继承Thread类具备多线程能力启动线程：子类对象.start（）不建议使用：避免OOP单继承局限性创建线程方法一： 运行结果[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9AOdwcMO-1680580929830)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230307160255323.png)]练习Thread，实现多线程同步下载图片： 运行结果：[外链图片转存
【Java】详细介绍Java实现线程的四种方式
鹏啊鹏
07-23 1465
详细介绍Java实现线程的4种方法、包含多个代码示例及lambda简化版本。
java并发编程实战源码,java并发编程实战pdf,Java
09-10
《Java并发编程实战》是Java并发编程领域的一本经典著作，它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例，可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
java并发编程实战源码-concurrent-programming:《Java并发编程实战》源码整理
05-25
《Java并发编程实战》这本书是Java并发编程领域的一本经典之作，它深入浅出地讲解了如何在Java环境中高效、安全地进行多线程编程。源码整理集合`concurrent-programming-master`提供了书中示例代码，对于学习和理解...
java并发编程2
02-15
Java并发编程是Java开发中的重要领域，特别是在多核处理器和分布式系统中，高效地利用并发可以极大地提升程序的性能和响应速度。以下是对标题和描述中所提及的几个知识点的详细解释： 1. **线程与并发** - **线程*...
java多线程进阶
10-18
这本书对JAVA多线程进阶帮助非常之大而且详细、融会贯通、看了必定打通多线程任督二脉
Java多线程详解
为梦想而努力（马英才）
02-27 5725
Java语言中的多线程的详细介绍。
【Java】多线程(进阶)
m0_72670269的博客
08-30 506
CAS 操作的 ABA 问题指的是，在某个线程执行 CAS 操作之前，共享变量的值被改变多次，并最终返回到了原始值，因此在执行 CAS 操作时，虽然当前变量的值与期望值相等，但实际上它已经被其他线程修改过了。它们的获取顺序是相反的，即 thread1 先获取 lock1，再获取 lock2，而 thread2 先获取 lock2，再获取 lock1。公平锁是一种按照线程请求的顺序来分配锁的锁机制。**当多个线程竞争一个公平锁时，锁会按照先来后到的顺序将锁分配给等待时间最长的线程，保证了线程获取锁的公平性。
Java进阶之多线程
guanshengg的博客
08-22 170
程序：是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
JAVA多线程进阶篇-Condition和Signal
qq_33479841的博客
09-28 1975
Condition是JAVA1.5中出现的，它的作用是对原生的wait()、notify()/notifyAll()方法进行增强，相对于传统的wait()和notify()方法，Condition中的await()和signal()这种方式实现线程中协作更加高效。Condition是一个接口，主要依赖于JUC中的Lock接口，它的await()、signal()方法都要在lock同步锁内完成，也就是该部分代码必须存在于lock.lock()、lock.unlock()之间。
Java的常用的四种多线程实现方式
最新发布
百锦再的博客
01-09 1万+
同时，还需要注意线程同步和共享资源的处理，以避免竞态条件和线程安全问题。可以通过加锁、使用线程安全的数据结构和避免对共享数据的直接修改来实现线程安全。Java中的多线程概念是指在一个程序中同时运行多个线程。线程是程序中执行的最小单位，它代表了一条独立的执行路径。线程调度是非确定性的，即线程的调度顺序不可预测。在多线程环境下，可能会出现资源竞争和数据不一致的问题。一旦线程启动，它就会在一个独立的执行线程中并发运行。在使用多线程时，需要注意线程安全性和资源管理，以避免出现并发问题。包中的相关类来实现。
java中实现多线程的三种方式
Mao_yafeng的博客
07-31 1万+
实现多线程的方法
Java多线程进阶详解
weixin_45082647的博客
06-11 1361
文章目录1、 1、
Java 线程之间通信
心有猛虎细嗅蔷薇
12-25 156
概念 用多线程的目的：更好的利用CPU的资源。因为所有的多线程代码都可以用单线程来实现。 多线程：指的是这个程序（一个进程）运行时产生了不止一个线程。 并行：多个CPU实例或者多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过CPU调度算法，让用户看上去同时执行，实际上从CPU操作层面不是真正的同时。 线程安全：经常用来描绘一段代码。指在并发的情况下，该代码经过多线程使用，线程的调...
Java并发编程深度解析
"《Java并发编程的艺术》是一本详细介绍Java并发编程技术的著作，由方腾飞、魏鹏程和晓明合著。本书旨在帮助读者理解并发编程的底层机制，并逐步学习设计并发程序的关键技术和设计模式。书中包含丰富的示例代码，以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值