java 通过Thread实现多线程

最新推荐文章于 2022-04-27 21:20:52 发布

fly_air

最新推荐文章于 2022-04-27 21:20:52 发布

阅读量705

点赞数

分类专栏： java 文章标签： java 多线程

java 专栏收录该内容

32 篇文章 1 订阅

订阅专栏

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	提交一个任务并开始执行。