码迷,mamicode.com
首页 > 编程语言 > 详细

多线程系列之 关于Java多线程的个人理解(一)

时间:2019-01-02 19:08:44      阅读:210      评论:0      收藏:0      [点我收藏+]

标签:top   计数器   reading   shutdown   多进程   panel   focus   relative   logs   

 

前言:多线程常常是程序员面试时会被问到的问题之一,也会被面试官用来衡量应聘者的编程思维和能力的重要参考指标;无论是在工作中还是在应对面试时,多线程都是一个绕不过去的话题。本文重点围绕多线程,借助Java语言来展开讨论

 

文章结构

  1. 什么是多线程
  2. 为什么要使用多线程
  3. 如何实现多线程
  4. 在实际项目中遇到的多线程问题

 

1.什么是多线程

1.1 先来聊一聊什么是进程

技术分享图片

 

如上图所示,以window操作系统为例,在win10操作系统进程管理,可以清楚的的看到在我们使用计算机的时候,后台是有很多像这样一个一个的进程在运行,这样一个一个的进程其实就是一个正在运行的程序;系统进行资源分配和调度的基本单位,竟争计算机系统资源的基本单位,是并发执行的程序在执行过程中分配和管理资源的基本单位。

 

1.2 什么是线程

 技术分享图片

 

如上图所示,可以看到操作系统上现在有185个进程,有2815个线程;线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源;(程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

1.3 什么是多线程

百度上是这么说的,多线程(英语:multithreading),是指从软件或者硬件上实现多个线程并发执行的技术。 个人理解,线程是要依赖于进程而存在的,毕竟他不能单独运行,所有在一个进程里面只有一个线程实例在执行就可以理解为单线程,有多个实例在执行则可以理解为多线程。

1.4 多线程与多进程的区别

  • 多进程:操作系统能同时运行多个任务(程序)。
  • 多线程:同一程序中有多个顺序流(线程)在执行。

 

2.为什么要使用多线程

换句话说,使用多线程到底有什么好处?

  1. 线程在程序中是独立的,并发的执行流,但是,与分隔的进程相比,进程中的线程之间的隔离程度要小。它们共享内存,文件句柄和其他每个进程应有的状态。
  2. 线程比进程具有更高的性能,这是由于同一个进程中的线程都有共性:多个线程将共享同一个进程虚拟空间。线程共享的环境包括:进程代码段,进程的公有数据等。利用这些共享的数据等,线程很容易实现相互之间的通信。
  1. 当操作系统创建一个进程时,必须为进程分配独立的内存空间,并分配大量相关资源:但创建一个线程则简单很多,因此使用多线程来实现并发比使用多进程实现并发的性能要高得多。
  2. 总结起来,使用多线程编程包含如下几个优点: (1)进程间不能共享内存,但线程之间可以共享内存非常容易。 (2)系统创建进程需要为该进程重新分配系统资源,但创建线程则代价小的多,因此使用多线程来实现多任务并发比多进程的效率高。 (3)Java语言内置多线程功能支持,而不是单纯地作为底层操作系统的调度方式,从而简化了Java的多线程编程。

 

3.如何实现多线程

首先要说一下,本文是基于Java语言来实现的多线程编程。在面向对象的编程思想指导下,实现多线程的方式有:

  • 继承Thread类创建多线程
  • 实现Runnable接口创建多线程
  • 实现Callable接口通过FutureTask包装器来创建Thread线程

3.1继承Thread类实现多线程

JDK 为我们提供了一个线程类Thread 我们可以继承这个类并重写run()方法 ,如下:

 1 package com.ultrapower.Mutilthread;
 2 /**
 3  * @Description: 继承Thread类实现多线程
 4  * @author fangtao
 5  */
 6 public class myThread extends Thread {
 7       private int index=0;
 8     
 9      @Override
10     public void run(){
11          while(true){ 
12         try {
13             Thread.sleep(1000);
14             System.out.println("进程号:"+this.currentThread().getId()+"执行-->"+(index++));
15           } catch (InterruptedException e) {    
16             e.printStackTrace();
17            }
18          }        
19     }
20 }

执行结果:

技术分享图片

 

 

小节: 通过继承Thread 类并重写run()方法 就可以启动新线程并执行自己定义在run()里的逻辑 。

 

3.2 实现Runnable接口创建多线程

如果自己的类已经继承另一个类,由于Java语言的单继承特性,就无法直接继承Thread;此时,可以实现一个Runnable接口,如下:

 

 1 package com.ultrapower.Mutilthread;
 2 /**
 3  * @Description: 实现Runable接口
 4  * @author fangtao
 5  * @date 2019-1-2 下午4:03:38
 6  */
 7 public class myThread2 implements Runnable {
 8 
 9     @Override
10     public void run(){ 
11         while(true){        
12         try {
13             Thread.sleep(1000);
14             System.out.println(Thread.currentThread().getId()+"  I‘m  running!");
15         } catch (InterruptedException e) {
16             e.printStackTrace();
17         }        
18       }
19     }
20 }

 

执行结果:

 1 public class TestmyThread {
 2 
 3     public static void main(String[] args) {
 4         Thread t1=new Thread(new myThread2());
 5         Thread t2=new Thread(new myThread2());
 6         Thread t3=new Thread(new myThread2());
 7         t1.start();t2.start();t3.start();
 8     }
 9 
10 }

 

执行结果:

 

 

事实上,当传入一个Runnable target参数给Thread后,Thread的run()方法就会调用target.run(),参考JDK源代码:

 

 

执行结果:

技术分享图片

 

 

3.3 实现Callable接口通过FutureTask包装器来创建Thread线程

3.3.1 Callable

Callable位于java.util.concurrent包下,它也是一个接口,在它里面也只声明了一个方法,只不过跟Runnable接口不一样,这个方法比较叫做call();

1 public interface Callable<V> {
2     /**
3      * Computes a result, or throws an exception if unable to do so.
4      *
5      * @return computed result
6      * @throws Exception if unable to compute a result
7      */
8     V call() throws Exception;
9 }

 

 

可以看到,这是一个泛型接口,call()函数返回的类型就是传递进来的V类型。

那么怎么使用Callable呢?一般情况下是配合ExecutorService来使用的,在ExecutorService接口中声明了若干 个submit方法的重载版本:

  1 <T> Future<T> submit(Callable<T> task);

2 <T> Future<T> submit(Runnable task, T result);

3 Future<?> submit(Runnable task); 

第一个submit方法里面的参数类型就是Callable。

  暂时只需要知道Callable一般是和ExecutorService配合来使用的,具体的使用方法讲在后面讲述。

  一般情况下我们使用第一个submit方法和第三个submit方法,第二个submit方法很少使用。

 

3.3.2 Future

 Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时 可以通过get方法获取执行结果,该方法会阻塞直到任务返回结果。

  Future类位于java.util.concurrent包下,它是一个接口:

 

1 public interface Future<V> {
2     boolean cancel(boolean mayInterruptIfRunning);
3     boolean isCancelled();
4     boolean isDone();
5     V get() throws InterruptedException, ExecutionException;
6     V get(long timeout, TimeUnit unit)
7         throws InterruptedException, ExecutionException, TimeoutException;
8 }

 

在Future接口中声明了5个方法,下面依次解释每个方法的作用:

  • cancel方法用来取消任务,如果取消任务成功则返回true,如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务,如果设置true,则表示可以取消正在执行过程中的任务。如果任务已经完成,则无论mayInterruptIfRunning为true还是false,此方法肯定返回false,即如果取消已经完成的任务会返回false;如果任务正在执行,若mayInterruptIfRunning设置为true,则返回true,若mayInterruptIfRunning设置为false,则返回false;如果任务还没有执行,则无论mayInterruptIfRunning为true还是false,肯定返回true。
  • isCancelled方法表示任务是否被取消成功,如果在任务正常完成前被取消成功,则返回 true。
  • isDone方法表示任务是否已经完成,若任务完成,则返回true;
  • get()方法用来获取执行结果,这个方法会产生阻塞,会一直等到任务执行完毕才返回;
  • get(long timeout, TimeUnit unit)用来获取执行结果,如果在指定时间内,还没获取到结果,就直接返回null。

也就是说Future提供了三种功能:

  1)判断任务是否完成;

  2)能够中断任务;

  3)能够获取任务执行结果;

  因为Future只是一个接口,所以是无法直接用来创建对象使用的,因此就有了下面的FutureTask。

 

3.3.3 FutureTask

我们先来看一下FutureTask的实现:

  1 public class FutureTask<V> implements RunnableFuture<V> 

FutureTask类实现了RunnableFuture接口,我们看一下RunnableFuture接口的实现:

  1 public interface RunnableFuture<V> extends Runnable, Future<V> { 2 void run(); 3 } 

可以看出RunnableFuture继承了Runnable接口和Future接口,而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值。

FutureTask提供了2个构造器:

  1 public FutureTask(Callable<V> callable) { }

3 public FutureTask(Runnable runnable, V result) { } 

事实上,FutureTask是Future接口的一个唯一实现类

代码示例:

1) 使用Callable+Future获取执行结果

 

 1 public class Test {
 2     public static void main(String[] args) {
 3         ExecutorService executor = Executors.newCachedThreadPool();
 4         Task task = new Task();
 5         Future<Integer> result = executor.submit(task);
 6         executor.shutdown();
 7          
 8         try {
 9             Thread.sleep(1000);
10         } catch (InterruptedException e1) {
11             e1.printStackTrace();
12         }
13          
14         System.out.println("主线程在执行任务");
15          
16         try {
17             System.out.println("task运行结果"+result.get());
18         } catch (InterruptedException e) {
19             e.printStackTrace();
20         } catch (ExecutionException e) {
21             e.printStackTrace();
22         }
23          
24         System.out.println("所有任务执行完毕");
25     }
26 }
27 class Task implements Callable<Integer>{
28     @Override
29     public Integer call() throws Exception {
30         System.out.println("子线程在进行计算");
31         Thread.sleep(3000);
32         int sum = 0;
33         for(int i=0;i<100;i++)
34             sum += i;
35         return sum;
36     }
37 }

 

执行结果:

 技术分享图片

 

2)使用Callable+FutureTask获取执行结果

 

 1 public class Test {
 2     public static void main(String[] args) {
 3         //第一种方式
 4         ExecutorService executor = Executors.newCachedThreadPool();
 5         Task task = new Task();
 6         FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
 7         executor.submit(futureTask);
 8         executor.shutdown();
 9          
10         //第二种方式,使用的是ExecutorService,一个使用的是Thread
11     
12          
13         try {
14             Thread.sleep(1000);
15         } catch (InterruptedException e1) {
16             e1.printStackTrace();
17         }
18          
19         System.out.println("主线程在执行任务");
20          
21         try {
22             System.out.println("task运行结果"+futureTask.get());
23         } catch (InterruptedException e) {
24             e.printStackTrace();
25         } catch (ExecutionException e) {
26             e.printStackTrace();
27         }
28          
29         System.out.println("所有任务执行完毕");
30     }
31 }
32 class Task implements Callable<Integer>{
33     @Override
34     public Integer call() throws Exception {
35         System.out.println("子线程在进行计算");
36         Thread.sleep(3000);
37         int sum = 0;
38         for(int i=0;i<100;i++)
39             sum += i;
40         return sum;
41     }
42 }

 

如果为了可取消性而使用 Future 但又不提供可用的结果,则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。


(项目中多线程的分享下次再写吧。。。。)

部分参自:http://www.cnblogs.com/dolphin0520/

 

 

技术分享图片

多线程系列之 关于Java多线程的个人理解(一)

标签:top   计数器   reading   shutdown   多进程   panel   focus   relative   logs   

原文地址:https://www.cnblogs.com/ft-greate/p/10209607.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!