java多线程并发全面解析

最新推荐文章于 2022-10-27 15:40:49 发布

gy0011

最新推荐文章于 2022-10-27 15:40:49 发布

阅读量646

点赞数 2

分类专栏： java源码

本文链接：https://blog.csdn.net/Anjihua/article/details/103035880

版权

本文全面解析Java多线程并发，包括线程状态、创建线程的方式、线程同步机制如`synchronized`和`Lock`，线程池的工作原理以及常见优化策略，还有死锁的预防和排查方法。通过实例讲解了`sleep()`、`wait()`、`notify()`等方法的区别，并介绍了`CountDownLatch`、`CyclicBarrier`、`Semaphore`等并发工具类的应用。

摘要由CSDN通过智能技术生成

实现并发的最直接的方式是在操作系统级别使用进程。进程是运行在它自己的地址空间内的自包容的程序。

以下源码来自于jdk1.8
线程状态

	public enum State {
   
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,		//新生

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,	//运行

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,	//阻塞

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called {@code Object.wait()}
         * on an object is waiting for another thread to call
         * {@code Object.notify()} or {@code Object.notifyAll()} on
         * that object. A thread that has called {@code Thread.join()}
         * is waiting for a specified thread to terminate.
         */
        WAITING,	//等待，一直等待	wait方法

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,	//超时等待，只等待一段时间   sleep方法

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;		//结束
    }

根据源码可以看到线程总共有6种状态，而不是5种；分别是

NEW 新生
RUNNABLE 运行
BLOCKED 阻塞
WAITING 等待
TIMED_WAITING 超时等待
TERMINATED 线程终止

Thread类包含interrupt()方法，因此可以终止阻塞的任务，这个方法将设置线程的中断状态。

yield() 使得线程放弃CPU执行时间，但是不使线程阻塞，线程从运行状态进入就绪状态，随时可能再次分得 CPU 时间。有可能当某个线程调用了 yield() 方法暂停之后进入就绪状态，它又马上抢占了CPU 的执行权，继续执行。

可以使用sleep()和wait()方法让线程进入阻塞状态
sleep和wait区别：
1、wait需要notify和notifyAll方法唤醒，sleep里面的参数是毫秒数，让线程等待多长时间。
2、wait会让线程释放锁，而sleep不会释放锁
3、wait方法是Object类的，而sleep方法是Thread类的

使用notify和notifyAll方法，或者java.util.concurrent类库中等价的signal()或signalAll()方法，线程才会进入就绪状态。

一个线程可以在其他线程之上调用join()方法，其效果是等待一段时间直到第二个线程结束才恢复。

线程的创建
有四种方式：
1、实现Runnable接口并重写run()方法

public class StartRun implements Runnable{
   
	public void run() {
   	
	//处理业务	
	 }
}
使用：//创建实现类对象
		StartRun st=new StartRun();
		//创建代理类对象
		Thread t=