java 通过Thread实现多线程

来源：互联网发布：企业积分制管理知乎编辑：程序博客网时间：2024/04/30 00:35

1. Thread

getID()

获取线程ID。

getName(), setName()

获取和设置线程名。

getPriority(), setPriority()

获取和设置线程优先级。

getState()

获取线程状态。

getThreadGroup()

获取线程所在的线程组。

isAlive()

获取线程是否已经启动并且没有终止。

isDaemon(), setDaemon()

获取和设置线程是否为守护线程。

isInterrupted()

获取线程是否被中断。

start()

开始线程。

join()

等待指定线程中终止。

interrupt()

中断线程

静态方法

currentThread()

获取当前线程。

sleep()

使当前线程休眠指定的时间。

yield()

使当前线程暂停执行，让其它等待的线程执行。

interrupted()

获取当前线程是否被中断。

2. 通过Thread实现多线程

1. 通过继承Thread类并覆盖Thread的run()方法创建一个新的线程类。

2. 使用该线程类创建线程对象。

public class ThreadTest
{
public static void main(String[] args) throws Exception
{
TestThread th = new TestThread("thread 1");
th.start();
th.join();
System.out.println("'main' ended.");
}
private static class TestThread extends Thread
{
public TestThread(String threadName)
{
super(threadName);
}
@Override
public void run()
{
String thName = Thread.currentThread().getName();
System.out.printf("'%s' started. /n", thName);
for (int i = 0; i < 10; i++)
{
System.out.println(i);
}
System.out.printf("'%s' ended. /n", thName);
}
}
}

3. 通过Runnable实现多线程

1. 创建一个Runnable接口的实现类（实现run()方法）。

2. 通过Thread类包含Runnable的构造方法创建线程对象。

Thread(Runnable target)

Thread(ThreadGroup group, Runnable target)

ThreadGroup group, Runnable target, String name)

public class RunnableTest
{
public static void main(String[] args) throws Exception
{
Thread th = new Thread(new TestRunnable(), "thread 1");
th.start();
th.join();
System.out.println("'main' ended.");
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
String thName = Thread.currentThread().getName();
System.out.printf("'%s' started. /n", thName);
for (int i = 0; i < 10; i++)
{
System.out.println(i);
}
System.out.printf("'%s' ended. /n", thName);
}
}
}

4. ThreadGroup

activeCount()

获取线程组中正在执行的线程数量。

activeGroupCount()

获取线程组中正在执行的线程组数量。

getMaxPriority(), setMaxPriority()

获取和设置最大优先级

getName()

获取线程组的名称。

getParent()

获取父线程组

interrupt()

中断线程组中的所有线程。

isDaemon(), setDaemon()

获取和设置线程组是否为守护线程。

parentOf(ThreadGroup)

判断线程组是否包含于指定线程组中。

5. 通过ThreadGroup管理线程

在创建线程对象时，通过包含ThreadGroup的构造方法创建，将线程加入指定线程组

Thread(ThreadGroup group, Runnable target)

Thread(ThreadGroup group, Runnable target, String name)

Thread(ThreadGroup group, String name)

public class ThreadGroupTest
{
public static void main(String[] args) throws Exception
{
// 创建线程组对象。
ThreadGroup tg = new ThreadGroup("group 1");
// 向线程组中加入10个线程。
for (int i = 0; i < 10; i++)
{
Thread th = new Thread(tg, new TestRunnable(), "thread " + i);
th.start();
}
// 等待2秒。
Thread.sleep(2000);
// 中断所有线程。
tg.interrupt();
// 输出
System.out.println(tg.activeCount());
}
private static class TestRunnable implements Runnable
{
@Override
public void run()
{
String thName = Thread.currentThread().getName();
System.out.printf("'%s' started. /n", thName);
while (!Thread.currentThread().isInterrupted())
{
}
System.out.printf("'%s' ended. /n", thName);
}
}
}

PART.2 通过Callable和FutureTask实现异步调用

1. Callable<V>

Ø V为返回值的类型。

Ø 实现Callable接口需实现call方法。

Ø 与Runnable的run方法相比，call方法具有返回值V和异常声明。

2. FutureTask<V>

V为返回值得类型。

cancel()

取消执行。

get()

阻塞获取执行结果。

get(long, TimeUnit)

指定阻塞的最长时间，获取执行结果。

isCancelled()

获取是否被取消。

isDone()

获取是否完成。

run()

开始执行。

3. 通过Callable和FutureTask异步执行

1. 创建一个Callable<V>的实现类。

2. 创建FutureTask<V>对象。

3. 执行创建的FutureTask对象。(run方法)

4. 通过FutureTask对象获取结果。(get方法)

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class FutureTaskTest
{
public static void main(String[] args)
{
FutureTask<Integer> ct = null;
ct = new FutureTask<Integer>(new TestCallable());
ct.run();
try
{
int ret = ct.get();
System.out.println(ret);
}
catch (InterruptedException e)
{
// ct.get() 时线程被中断。
e.printStackTrace();
}
catch (ExecutionException e)
{
// Callable在执行时出现异常。
e.printStackTrace();
}
}
private static class TestCallable implements Callable<Integer>
{
@Override
public Integer call() throws Exception
{
double i = Math.random() * 100;
return (int)i;
}
}
}

4．处理FutureTask执行时发生的异常

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class FutureTaskExceptionTest
{
public static void main(String[] args)
{
FutureTask<Integer> ct = null;
ct = new FutureTask<Integer>(new TestCallable());
ct.run();
try
{
int ret = ct.get();
System.out.println(ret);
}
catch (InterruptedException e)
{
// ct.get() 时线程被中断。
e.printStackTrace();
}
catch (ExecutionException e)
{
// Callable在执行时出现异常。
System.out.println(e.getCause().getMessage());
System.out.println(e.getMessage());
}
}
private static class TestCallable implements Callable<Integer>
{
@Override
public Integer call() throws Exception
{
throw new Exception("An test exception.");
}
}
}

PART.3 通过ExecutorService实现多线程

1. ExecutorService

awaitTermination

等待所有任务结束。

invokeAll

执行集合中的所有任务，返回所有Future。该方法将等待所有任务结束或指定的时间。

invokeAny

执行集合中的一个任务，返回该任务得返回值。

isShutdown

获取ExecutorService是否被shutdown。

isTerminated

获取是否所有任务已经结束。

Shutdown

等待所有正在执行的任务结束。将没有执行的任务返回。不执行后新的任务。

shutdownNow

中断正在执行的任务。返回没有执行的任务。

submit

提交一个任务并开始执行。

2. 创建ExecutorService

Executors.newCachedThreadPool

Executors.newFixedThreadPool

Executors.newScheduledThreadPool

Executors.newSingleThreadExecutor

Executors.newSingleThreadScheduledExecutor

3. 通过ExecutorService实现多线程

1. 创建ExecutorService对象。

2. 向ExecutorServices对象提交任务。

3. 获得结果。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ExecutorServiceTest
{
public static void main(String[] args) throws Exception
{
ExecutorService es = Executors.newCachedThreadPool();
// 创建10个任务，将这些任务交由ExecutorService执行，保存这些任务的Future到List。
List<Future<Integer>> fs = new ArrayList<Future<Integer>>(10);
for (int i = 0; i < 10; i++)
{
TestCallable t = new TestCallable();
Future<Integer> f = es.submit(t);
fs.add(f);
}
// 等待执行结束。
Thread.sleep(1000);
// 输出执行结果。
for (Future<Integer> f : fs)
{
System.out.println(f.get());
}
// 关闭ExecutorService。
es.shutdown();
}
private static class TestCallable implements Callable<Integer>
{
@Override
public Integer call() throws Exception
{
double ret = Math.random() * 100;
return (int)ret;
}
}
}

4. 关闭ExecutorService

shutdown() 等待任务结束

shutdownNow() 中断任务

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ExecutorServiceShutdownTest
{
public static void main(String[] args) throws Exception
{
// PART 1 测试shutdownNow()。
System.out.println("----- PART 1");
// 创建ExecutorService。
ExecutorService es = Executors.newCachedThreadPool();
// 开始10个任务。
System.out.println("----- Start all tasks...");
for (int i = 0; i < 10; i++)
{
TestCallable task = new TestCallable("task " + i);
es.submit(task);
}
// 等待5秒。在此期间可能有任务结束。
System.out.println("----- Wait for 5 seconds.");
Thread.sleep(5000);
// 结束所有任务。
System.out.println("----- Shutdown all tasks now.");
es.shutdownNow();
System.out.println("----- End of PART 1");
Thread.sleep(1000);
// 测试shutdown()。
System.out.println("----- PART 2");
Thread.sleep(1000);
// 创建ExecutorService。
es = Executors.newCachedThreadPool();
// 开始10个任务。
System.out.println("----- Start all tasks...");
for (int i = 0; i < 10; i++)
{
TestCallable task = new TestCallable("task " + i);
es.submit(task);
}
// 等待5秒。在此期间可能有任务结束。
System.out.println("----- Wait for 5 seconds.");
Thread.sleep(5000);
// 结束所有任务。
System.out.println("----- Shutdown all tasks.");
es.shutdown();
System.out.println("----- End of main.");
}
private static class TestCallable implements Callable<Void>
{
private String name;
public TestCallable(String name)
{
this.name = name;
}
@Override
public Void call() throws Exception
{
System.out.printf("'%s' started. /n", name);
// 等待3 - 12秒。
try
{
int w = (int)(Math.random() * 10 + 3);
Thread.sleep(w*1000);
}
catch (InterruptedException e)
{
System.out.printf("'%s' interrupted. /n", name);
}
System.out.printf("'%s' ended. /n", name);
return null;
}
}
}

0 0