Java 多线程(一)

2019独角兽企业重金招聘Python工程师标准>>>

一、多线程的一些概念。

多线程：指的是这个程序（一个进程）运行时产生了不止一个线程。

并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。

并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。

二、多线程的一些状态

Thread类中有一个State枚举类，它代表着线程的几个状态：

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 <tt>Object.wait()</tt>
 \* on an object is waiting for another thread to call
 \* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
 \* that object. A thread that has called <tt>Thread.join()</tt>
 \* is waiting for a specified thread to terminate.
 */
WAITING,

/\*\*
 \* 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,

/\*\*
 \* Thread state for a terminated thread.
 \* The thread has completed execution.
 */
TERMINATED;

}

NEW：表示线程初始化。

RUNNABLE：表示线程在java虚拟机处于运行状态，但是也有可能在进程中等待操作系统的其他资源进行。

BLOCKED：表示线程处于阻塞状态

WAITING：表示线程正在等待中

TIMED_WAITING：表示线程正在某个时间范围内等待中

TERMINATED：表示线程终止。

以上几个状态可能理解起来会有点难，在网上找了一个图可以很好的解释多线程几个状态之间的联系和转换：

最值得注意的是BLOCKED这个状态，线程在RUNNING的过程中随时可能会遇到阻塞(BLOCKED)情况，比如说：

调用join()和sleep()方法，sleep()时间结束或被打断，join()中断,IO完成都会回到Runnable状态，等待JVM的调度。

调用wait()，使该线程处于等待池(wait blocked pool),直到notify()/notifyAll()，线程被唤醒被放到锁定池(lock blocked pool )，释放同步锁使线程回到可运行状态（Runnable） 。

对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。

此外，在runnable状态的线程是处于被调度的线程，此时的调度顺序是不一定的。Thread类中的yield方法可以让一个running状态的线程转入runnable。

三、多线程的用法

1.继承Thread
    * 定义类继承Thread
    * 重写run方法
    * 把新线程要做的事写在run方法中
    * 创建线程对象
    * 开启新线程, 内部会自动执行run方法

2.实现Runnable
    * 定义类实现Runnable接口
    * 实现run方法
    * 把新线程要做的事写在run方法中
    * 创建自定义的Runnable的子类对象
    * 创建Thread对象, 传入Runnable
    * 调用start()开启新线程, 内部会自动调用Runnable的run()方法

3.匿名内部类：

new Thread(() -> {
    for(int i=0;i<10;i++)
    System.out.println("线程1_i="+i);
}).start();

 

转载于:https://my.oschina.net/siwcky90/blog/2253622