1.如何实现多线程
1.1实现Runnable接口，实现run()方法。
public class Main4 implements Runnable {
public static void main(String[] args) {
Main4 m = new Main4();
new Thread(m).start();
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
}
}
1.2继承Thread接口，重写run()方法。
public class Main4 extends Thread {
public static void main(String[] args) {
new Main4().start();
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
}
}
1.3实现Callable接口，实现call()方法。
public class Main4 implements Callable {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable c = new Main4();
FutureTask<Integer> ft = new FutureTask<>(c);
new Thread(ft).start();
System.out.println(ft.get());
}
@Override
public Integer call() throws Exception {
int i = 0;
for (i = 0; i < 10; i++) {}
return i;
}
}
2.Runnable、Thread、Callable三种方式实现多线程的区别
2.1Runnable
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
Runnable接口很简单，里面只有一个抽象方法run()。run()方法里面的是这个线程要执行的内容。
2.2Thread
public class Thread implements Runnable {
public Thread() {
init(null, null, "Thread-" + nextThreadNum(), 0);
}
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
Thread(Runnable target, AccessControlContext acc) {
init(null, target, "Thread-" + nextThreadNum(), 0, acc);
}
public Thread(ThreadGroup group, Runnable target) {
init(group, target, "Thread-" + nextThreadNum(), 0);
}
public Thread(String name) {
init(null, null, name, 0);
}
public Thread(ThreadGroup group, String name) {
init(group, null, name, 0);
}
public Thread(ThreadGroup group, String name) {
init(group, null, name, 0);
}
public Thread(Runnable target, String name) {
init(null, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target, String name) {
init(group, target, name, 0);
}
public Thread(ThreadGroup group, Runnable target, String name,
long stackSize) {
init(group, target, name, stackSize);
}
}
Thread类实现了Runnable接口，因此我们继承Thread，实际上也是间接的实现了Runnable接口。
Thread中一共有9个构造函数，但是里面实际调用的分别是：
init(ThreadGroup g, Runnable target, String name, long stackSize)
init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc)
我们查看了第一个init()方法源码，在内部其实是调用了第二个init方法，将最后一个参数置空。因此我们只要详细看5个参数的init()方法即可。
private void init(ThreadGroup g, Runnable target, String name,
long stackSize) {
init(g, target, name, stackSize, null); //内部其实调用了另一个init方法
} private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc) {
if (name == null) {throw new NullPointerException("name cannot be null");
} this.name = name; //指定线程名称 Thread parent = currentThread(); //获取当前线程
SecurityManager security = System.getSecurityManager();
if (g == null) {
/* Determine if it's an applet or not */ /* If there is a security manager, ask the security manager
what to do. */
if (security != null) {
g = security.getThreadGroup(); //使用安全管理器要求的线程组
} /* If the security doesn't have a strong opinion of the matter
use the parent thread group. */
if (g == null) {
g = parent.getThreadGroup(); //安全性没有明确的要求，可以使用父类线程组。
}
} /* checkAccess regardless of whether or not threadgroup is
explicitly passed in. */
g.checkAccess(); /*
* Do we have the required permissions?
*/
if (security != null) {
if (isCCLOverridden(getClass())) {
security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
}
} g.addUnstarted(); this.group = g; //线程组
this.daemon = parent.isDaemon(); //是否守护线程
this.priority = parent.getPriority(); //优先级
if (security == null || isCCLOverridden(parent.getClass())) //上下文类加载器
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext();
this.target = target; //将被执行的目标线程
setPriority(priority); //设置优先级(1-10)，不在范围内则抛出异常。由于线程组的最大优先级可以设置，参数大于线程组的最大优先级，取线程组最大优先级。
if (parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
/* Stash the specified stack size in case the VM cares */
this.stackSize = stackSize; /* Set thread ID */
tid = nextThreadID(); //线程的唯一id
}
2.3Callable
@FunctionalInterface
public interface Callable<V> { V call() throws Exception;
}
Callable接口也很简单，里面只有一个方法call()。
使用Callable时，需要使用FutureTask类进行调用。
查看FutureTask类的继承关系，可知其最上面也是实现了Runnable接口。
查看FutureTask的构造函数，一共有两个。
FutureTask(Callable<V> callable)：futureTask内部有一个私有变量Callable，令其等于传入的callable。
FutureTask(Runnable runnable, V result)：调用Executors的静态方法，创建内部一个实现了callable接口的内部类，call()方法执行Runnable的run()，执行成功后返回result。
源码如下：
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result); //见下方
this.state = NEW; // ensure visibility of callable
}
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
在FutureTask中定义了运行状态一共有7种(注意它们各自的数值，会经常使用>=、<=等方式来处理逻辑走向)：
/*
* NEW -> COMPLETING -> NORMAL 新建->执行->完成
* NEW -> COMPLETING -> EXCEPTIONAL 新建->执行->异常
* NEW -> CANCELLED 新建->取消
* NEW -> INTERRUPTING -> INTERRUPTED 新建->中断运行->中断状态
*/
private volatile int state;
private static final int NEW = ;
private static final int COMPLETING = ;
private static final int NORMAL = ;
private static final int EXCEPTIONAL = ;
private static final int CANCELLED = ;
private static final int INTERRUPTING = ;
private static final int INTERRUPTED = ;
FutureTask的run()方法，内部核心代码是调用了callable.call()。如果顺利执行，会执行set(result)方法，将结果保存到成员变量private Object outcome中。
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
FutureTask的get()方法，在线程t1中调用线程t2的get()方法，可见如果t2的run()仍未执行完成，则会一直等待执行完成后，获取返回值，才会继续往下执行t1。
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L); //如果线程刚被新建，或正在运行，等待执行完成。
return report(s); //返回run()方法中保存的outcome
}
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L; //在线程类中，0通常用来代表不限制时间
WaitNode q = null;
boolean queued = false;
for (;;) {
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
else if (s == COMPLETING) // cannot time out yet
Thread.yield(); //仍在执行中，令当前线程让出cpu资源。因为通常是在一个线程t1里调用另一个线程t2的get()方法，即令t1让出cpu，t2可以参与竞争
else if (q == null)
q = new WaitNode();
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}
3总结
实际上不论是使用哪一种方式实现，最后调用时都是需要使用Thread类的start()方法进行调用。因此，线程的主要类，我们研究Thread类即可。
线程的状态state，在Thread类中以内部枚举的形式存在
public enum State {
NEW, //新建状态，尚未执行start方法
RUNNABLE, //可运行状态，已经执行start方法，竞争cpu资源
BLOCKED, //阻塞状态，等待获取锁进入代码块
WAITING, //等待状态，线程进入此状态只有三种方法：wait()、join()、park()，注意这些方法都没有参数，即不会由于超时问题而重新变为可运行或执行状态
TIMED_WAITING, //定时等待状态，进入此方法的方式与waiting类似，但是该方法有时间限制，当达到指定时间后会重新变为Runnable，如sleep、wait(long)等
TERMINATED; //终止状态，线程已经执行完毕
}
几种常用方法介绍：
yield()：当前线程暂停执行，让出cpu，重新竞争。有可能仍然是该线程竞争到cpu。
sleep(long)：当前线程暂停执行(不释放锁)，休眠指定毫秒数，其他线程竞争cpu，当指定时间过去，当前线程继续执行。
interrupt()：中断当前线程，通常用来让内部是while(!Thread.currentThread().isInterrupt())的run()方法中断运行。
wait()：令当前线程进入等待状态(释放锁)，只能使用在synchronized块中。因此，当线程执行wait方法的时候一定是取得了锁。可以通过notify()或notifyAll()方法重新唤醒
join()：通常是在一个线程t1里面调用另一个线程t2的join方法，当t1执行到这里的时候，会获取t2的锁并执行t2，直到t2执行完毕，再继续执行t1下面的步骤。
join(long)：与join()类似，不同处在于t1最多只会等待long秒，当时间到达后，如果t2仍没有执行完毕，那么t1也会继续执行下面的步骤。
join()方法例子：
public class Main4 extends Thread {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Main4 m1 = new Main4();
Main4 m2 = new Main4();
m1.start();
m1.join();
System.out.println("---------------main---------------");
m2.start();
}
@Override
public void run() {
int i = 0;
for (i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "[i="+i+"]");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
如上程序，控制台会先打印m1线程的0-9，然后再打印"---main---"，最后打印m2线程的0-9.
如果我们将m1.join()改为m1.join(1000)，那么会先打印m1的0，这时达到参数1000ms，main线程会继续并行往下执行，打印"---main---"，然后启动m2线程，m1与m2争夺cpu竞相打印。
需要注意的是，join(0)不是等待0ms，而是等价于join()方法。源码中join()内部只有一行代码：join(0)。
_