[PHP] Java多线程超级详解(只看这篇就够了)

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

  

• 新建状态：当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时仅由JVM为其分配内存，并初始化其成员变量的值  
  
• 就绪状态：当线程对象调用了start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，等待调度运行  
  
• 运行状态：如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态  
  
• 阻塞状态：当处于运行状态的线程失去所占用资源之后，便进入阻塞状态  
  
• 死亡状态：线程在run()方法执行结束后进入死亡状态。此外，如果线程执行了interrupt()或stop()方法，那么它也会以异常退出的方式进入死亡状态。
  

可以对照上面的线程状态流转图来看具体的方法，这样更清楚具体作用：

package com.mikechen.java.multithread;

/**
* 多线程创建：继承Thread
*
* @author mikechen
*/
class MyThread extends Thread {
  private int i = 0;

  @Override
  public void run() {
    for (i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName() + " " + i);
    }
  }

  public static void main(String[] args) {
    MyThread myThread=new MyThread();
    myThread.start();
  }

}

package com.mikechen.java.multithread;

/**
* 多线程创建：实现Runnable接口
*
* @author mikechen
*/
public class MyRunnable implements Runnable {
  private int i = 0;
  @Override
  public void run() {
    for (i = 0; i < 10; i++) {
      System.out.println(Thread.currentThread().getName() + " " + i);
    }
  }

  public static void main(String[] args) {
    Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象
    Thread thread = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程
    thread.start();
  }
}

package com.mikechen.java.multithread;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
* 多线程创建：线程池
*
* @author mikechen
*/
public class MyThreadPool {

    public static void main(String[] args) {
      //创建带有5个线程的线程池
      //返回的实际上是ExecutorService,而ExecutorService是Executor的子接口
      Executor threadPool = Executors.newFixedThreadPool(5);
      for(int i = 0 ;i < 10 ; i++) {
        threadPool.execute(new Runnable() {
          public void run() {
            System.out.println(Thread.currentThread().getName()+" is running");
          }
        });
      }

    }


}

public ThreadPoolExecutor(
  int corePoolSize,
  int maximumPoolSize,
  long keepAliveTime,
  TimeUnit unit,
  BlockingQueue<Runnable> workQueue,
  ThreadFactory threadFactory,
  RejectedExecutionHandler handler
)
{
  ....
}

package com.mikechen.java.multithread;

/**
* 多线程创建：匿名内部类
*
* @author mikechen
*/
public class MyThreadAnonymous {


    public static void main(String[] args) {
      //方式1：相当于继承了Thread类，作为子类重写run()实现
      new Thread() {
        public void run() {
          System.out.println("匿名内部类创建线程方式1...");
        };
      }.start();

      //方式2:实现Runnable,Runnable作为匿名内部类
      new Thread(new Runnable() {
        public void run() {
          System.out.println("匿名内部类创建线程方式2...");
        }
      } ).start();
    }

}

package com.mikechen.java.multithread;

/**
* 多线程创建：lambda表达式
*
* @author mikechen
*/
public class MyThreadLambda {
  public static void main(String[] args) {
    //匿名内部类创建多线程
    new Thread(){
      @Override
      public void run() {
        System.out.println(Thread.currentThread().getName()+"mikchen的互联网架构创建新线程1");
      }
    }.start();


    //使用Lambda表达式，实现多线程
    new Thread(()->{
      System.out.println(Thread.currentThread().getName()+"mikchen的互联网架构创建新线程2");
    }).start();

    //优化Lambda
    new Thread(()-> System.out.println(Thread.currentThread().getName()+"mikchen的互联网架构创建新线程3")).start();

  }
}

/**
* 用在普通方法
*/
private synchronized void synchronizedMethod() {
System.out.println("--synchronizedMethod start--");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("--synchronizedMethod end--");
}

/**
* 用在静态方法
*/
private synchronized static void synchronizedStaticMethod() {
System.out.println("synchronizedStaticMethod start");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("synchronizedStaticMethod end");
}

/**
* 用在类
*/
private void synchronizedClass() {
synchronized (SynchronizedTest.class) {
System.out.println("synchronizedClass start");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("synchronizedClass end");
}
}

  

• 对象头(Header)  
  
• 实例数据(Instance Data)  
  
• 对齐填充(Padding)
  

i++;   // 操作2
i = j; // 操作3
i = i + 1; // 操作4

public void add(int m) {
  synchronized(lockA) { // 获得lockA的锁
    this.value += m;
    synchronized(lockB) { // 获得lockB的锁
      this.another += m;
    } // 释放lockB的锁
  } // 释放lockA的锁
}
public void dec(int m) {
  synchronized(lockB) { // 获得lockB的锁
    this.another -= m;
    synchronized(lockA) { // 获得lockA的锁
      this.value -= m;
    } // 释放lockA的锁
  } // 释放lockB的锁
}

CPU是很宝贵的资源，速度也非常快，为了保证均衡，通常会给不同的线程分配时间片，当CPU从一个线程切换到另外一个线程的时候，CPU需要保存当前线程的本地数据，程序指针等状态，并加载下一个要执行的线程的本地数据，程序指针等，这个切换称之为上下文切换。