Java 多线程
线程和进程
进程：进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当一个程序进入内存运行时，就成为一个进程。
线程：线程是进程的组成部分，一个进程可以拥有多个线程，而一个线程必须拥有一个父进程。线程可以拥有自己的堆栈，自己的程序计数器和自己的局部变量，但不能拥有系统资源。它与父进程的其他线程共享该进程的所有资源。
主线程：在Java中必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束。这个线程在java中称之为主线程。
多线程原理：多线程是通过并发的方式进行。对于一个CPU它在某个时间点上，只能执行一个程序，即同一时间只能运行一个进程，CPU会不断地在这些进程之间切换，每个线程执行一个时间。因为CPU的执行速度相对我们的感觉实在太快了，虽然CPU在多个进程之间轮换执行，但我们自己感到好像多个进程在同时执行。
CPU会在多个进程之间做着切换，如果我们开启的程序过多，CPU切换到每一个进程的时间也会变长，我们也会感觉机器运行变慢。所以合理的使用多线程可以提高效率，但是大量使用，并不能给我们带来效率上的提高。
线程状态转换
1、新建状态(New): 新创建了一个线程对象。
2、就绪状态(Runnable): 线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）： 就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）
5、死亡状态（Dead）： 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
创建线程
Java创建线程的四种方式：1.继承Thread类覆写run()方法实现多线程 2.实现Runnable()接口实现多线程，而后同样覆写run()方法 3.实现Callable接口覆写call()方法实现多线程 4.通过线程池启动多线程
1.继承Thread类实现多线程
-
创建线程的步骤：
-
定义一个类继承Thread。
-
重写run()方法。
-
创建子类对象，就是创建线程对象。
-
调用start()方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。
class Dem1 extends Thread{//继承Thread类
private String name;
Dem1(String name){
this.name=name;
}
@Override
public void run() {//重写run方法
for (int i=0;i<3;i++){
//Thread.currentThread().getName() 获得当前线程对象 名称
System.out.println("Thread:"+Thread.currentThread().getName()+" name:"+name+" i="+i);
}
}
}
public class ThreadDem1 {
public static void main(String[] args) {
Dem1 d1=new Dem1("张三");//创建对象
Dem1 d2=new Dem1("李四");//创建对象
d1.run(); //对象直接执行run方法
d1.start();//start方法开启线程执行run方法
d2.start();//start方法开启线程执行run方法
}
}
结果：
main方法中程序由主线程执行，当开启多个线程时，线程间互相切换。
注意：当主线程执行完成了，并不代表程序就结束，如果此时还有其他线程正常执行，程序仍然在执行过程中。当任何一个线程出现了异常，其他线程还是会继续运行的。异常只会影响到异常所属的那个线程。
class Dem1 extends Thread{
private String name;
Dem1(String name){
this.name=name;
}
@Override
public void run() {
for (int i=0;i<3;i++){
System.out.println("Thread:"+Thread.currentThread().getName()+" name:"+name+" i="+i);
}
}
}
class Dem2 extends Thread{
private String name;
Dem2(String name){
this.name=name;
}
@Override
public void run() {
System.out.println(2/0);//会发生异常的代码
System.out.println(name);
}
}
public class ThreadDem1 {
public static void main(String[] args) {
Dem1 d1=new Dem1("张三");
Dem2 d2=new Dem2("李四");
d2.start();
d1.start();
}
}
执行结果：
程序执行时由于d2开启的线程中发生了异常，线程终止，该对象的"name"属性并没有被输出，但该线程异常后并没有影响其他线程的运行，d1开启的线程正常执行。
2.实现Runnable接口
- 定义类实现Runnable接口。
- 覆盖接口中的run方法。
- 创建Thread类的对象。
- 将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
- 调用Thread类的start方法开启线程。
public class TreadDem2 {
public static void main(String[] args) {
Dem3 d1=new Dem3();//创建对象
Dem3 d2=new Dem3();//创建对象
Thread t1=new Thread(d1);//类对象作为参数传递给Thread类的构造函数
Thread t2=new Thread(d2);//类对象作为参数传递给Thread类的构造函数
t1.start();//开启线程
t2.start();//开启线程
}
}
class Dem3 implements Runnable{//实现 Runable接口
private String name;
@Override
public void run() {//覆写run方法
for (int i=0;i<10;i++){
System.out.println("Thread:"+Thread.currentThread().getName()+" name:"+name+" i="+i);
}
}
}
执行结果：
3.实现Callable接口
Callable接口是Java5新增的接口，它不是Runnable接口的子接口，所以就不能作为Thread的target。但call()方法还有一个返回值，如何获取这个返回值呢？Java5提供了Future接口来代表Callable接口里call()方法的返回值，并为Future接口提供了一个FutureTask实现类，该实现类实现了Future接口，同时也实现了Runnable接口（可以作为Thread类的target了）
Future 接口定义了如下几个公共方法来控制它关联的Callable任务：
（1）boolean cancel(boolean mayInterruptIfRunning)：试图取消该Future里关联的Callable任务。
（2）V get()：返回Callable任务里call()方法的返回值。调用该方法将导致程序阻塞，必须等到子线程结束后才会得到返回值。
（3）V get(long timeout,TimeUnit unit)：返回Callable任务里call()方法的返回值。该方法让程序最多阻塞timeout和unit指定的时间。如果经过指定时间Callable任务依然没有返回值，将会抛出TimeoutException异常。
（4）boolean isCancelled()：如果在Callable任务正常完成前被取消，则返回true。
（5）boolean isDone()：如果Callable任务完成，返回true。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 10; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
sum += i;
}
return sum;
}
}
public class ThreadDemo4 {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
Thread t=new Thread(futureTask);
t.start();
try {
//6.获取Callable中call方法的返回值(如果对call方法的返回值不感兴趣，就不需要调用futureTask.get()方法)
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为：" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
执行结果：
线程停止&interrupt方法
线程结束：就是让线程任务代码执行完，run方法结束。run方法咋结束呢？run方法中通常都定义循环，只要控制住循环就可以了。
如果目标线程等待很长时间，则应使用 interrupt 方法来中断该等待。所谓的中断并不是停止线程。interrupt的功能是将线程的冻结状态清除，让线程恢复到的运行状态(让线程重新具备cpu的执行资格)。
因为是强制性的所以会有异常InterruptedException发生，可以在catch中捕获异常，在异常处理中，改变标记让循环结束，让run方法结束。
class Demo implements Runnable {
private boolean flag = true;
public synchronized void run() {
while (flag) {
try {
wait();
} catch (InterruptedException e) {
System.out.println(
Thread.currentThread().toString() + "....." + e.toString());
changeFlag();
}
System.out.println(Thread.currentThread().getName() + "----->");
}
}
// 对标记的修改方法。
public void changeFlag() {
flag = false;
}
}
class StopThreadDemo {
public static void main(String[] args) {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
int x = 0;
while (true) {
if (++x == 50)// 条件满足。
{
// d.changeFlag();
// 改变线程任务代码的标记，让其他线程也结束。
// 对t1线程对象进行中断状态的清除，强制让其恢复到运行状态。
t1.interrupt();
// 对t2线程对象进行中断状态的清除，强制让其恢复到运行状态。
t2.interrupt();
break;// 跳出循环，主线程可以结束。
}
System.out.println("main-------->" + x);
}
System.out.println("over");
}
}
join方法和yield方法
class Demo implements Runnable
{
public void run()
{
for(int x=1; x<=40; x++)
{
System.out.println(Thread.currentThread().getName()+"------>"+x);
Thread.yield();//线程临时暂停。将执行权释放，让其他线程有机会获取执行权。
}
}
}
class JoinThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
//主线程执行到这里，知道t1要加入执行，主线程释放了执行权，
//执行资格并处于冻结状态，什么时候恢复呢？等t1线程执行完。
// try{t1.join();}catch(InterruptedException e){}//用于临时加入一个运算的线程。让该线程运算完，程序才会继续执行。
for(int x=1; x<=50; x++)
{
System.out.println("main---------->"+x);
}
System.out.println("over");
}
}
4、Executor 的理解和使用
之前使用线程的时候都是使用new Thread来进行线程的创建，但是这样会有一些问题。如：
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
下面我们来了解下java中Executors的线程池。
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
1、newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(index);
}
});
}
线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
2、newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。
3、newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
表示延迟3秒执行。定期执行示例代码如下：
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
表示延迟1秒后每3秒执行一次。ScheduledExecutorService比Timer更安全，功能更强大，后面会有一篇单独进行对比。
4、newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
扫一扫
3444
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
