Java基础加强之 Java5的线程并发库

最新推荐文章于 2022-04-19 11:12:54 发布

yuanqiwyj

最新推荐文章于 2022-04-19 11:12:54 发布

阅读量435

点赞数

本文链接：https://blog.csdn.net/yuanqiwyj/article/details/39118533

版权

<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！

01. 传统线程技术回顾

创建线程的两种传统方式：

1、在Thread子类覆盖的run方法中编写运行代码；

涉及一个以往知识点，能否在run方法声明上抛出InterruptedException异常？以便省略run方法内部对Thread.sleep()语句的try……catch处理？

答：不能，因为Thread类的run方法没有抛异常，子类覆盖run方法时也不能抛异常。

2、在传递给Thread对象的Runnable对象的run方法中编写代码；

Thread thread1 = new Thread(){

@Override

publicvoid run()

{

while(true)

{

try {

Thread.sleep(500);

} //不能让run方法throws异常，因为父类run没有抛异常

catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName());//this.getName()也行

}

};

thread1.start();

//创建Thread对象，并传入一个Runnble对象到构造方法

Thread thread2 = new Thread(new Runnable(){

@Override

publicvoid run()

{

while(true)

{

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

//此处就不能用this.getName，因为this代表Runnable子类对象

System.out.println(Thread.currentThread().getName());

}

});

这两种方式有什么区别？为什么通常人们采用第二种（实现Runnable接口）？

都是创建一个线程，只是第二种方式更加体现面向对象的思想；创建一个线程，线程要运行的代码封装到Runnable对象中（run方法）。

3、总结：查看Thread对象的run方法的源代码，可以看到其实这两种方式都是在调用Thread对象的run方法，如果Thread类的run方法没有被覆盖（不是继承Thread）并且为该Thread对象设置了一个Runnable对象，该run方法会调用Runnable对象的run方法。

Public void run()
{

if(target != null)

{//当Thread构造方法中传递了Runnable对象就执行Runnable的run方法。

target.run();

}

4、问题：如果在Thread子类覆盖的run方法中编写了运行代码，也为Thread子类对象传递了一个Runnable对象，那么，线程运行时的执行代码是子类的run方法的代码还是Runnable对象的run方法的代码？

答：（Thread子类的run），因为子类覆盖了父类的run方法，子类对象调用start方法时，会到自己的类中找run方法，如果没有找到就会执行父类的run方法，而父类（Thread）的run方法中会去调用Runnable对象的run方法。只要覆盖了Thread中的run方法，就不会执行Runnable对象的run方法。

涉及到一个以往的知识点：匿名内部类对象的构造方法如何调用父类的非默认构造方法。

5、多线程机制会提高程序的运行效率吗？为什么会有多线程下载呢？

答：多线程不会提高程序的运行效率甚至更慢，因为cpu同一时间只能执行一个线程，如果要在几个线程之间切换需要时间。

计算机并没有快，只是抢了服务器的带宽。因为多（10）个线程下载，服务器以为多（10）个客户端在下载，所以给每个客服端提供20k，合起来就200k。

02. 传统定时器技术回顾

java.util
类 Timer

一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。

void	schedule(TimerTask task, long delay) 安排在指定延迟后执行指定的任务。
void	schedule(TimerTask task, long delay, long period) 安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。

java.util
类 TimerTask 由 Timer 安排为一次执行或重复执行的任务。实现了Runnable接口。

boolean	cancel() 取消此计时器任务。
abstract void	run() 此计时器任务要执行的操作。

定时器的应用：

//两个时间间隔发生，方式一：定义计数器

class MyTimerTaskextends TimerTask

{

@Override

publicvoid run()

{

count= (count+1)%2;

System.out.println("bombing!");

new Timer().schedule(new MyTimerTask(), 2000+2000*count);

}

new Timer().schedule(new MyTimerTask(), 2000); //启动炸弹，2秒后

03. 传统线程互斥技术

线程的互斥与同步通信：

1、线程安全问题可以用银行转账来解释；两个业务同时拿到余额，一个存一个取。

2、使用synchronized代码块及其原理；任意对象都可作为锁

3、使用synchronized方法； this

4、分析静态方法所使用的同步监视器对象是什么？

方法所在类文件字节码

总结：如果多个线程执行的代码要求同步，需要加上synchronized；即一个线程没有将synchronized修饰的代码执行完时，其他线程不能进来执行。这里要注意，需要同步的代码（同一份）可以定义在不同的块中，但是为了同步，必须保证使用同一把锁。

线程的同步互斥的图文解说：

线程1 线程2 synchronized（obj）的作用主要是其中obj的作用

| |

------------------------------- a和b这两段代码被两个线程执行时要互斥；

a……… b…… 要互斥的代码必须用synchronized代码块包围。

第二组代码要互斥，即c与d互斥，但a与c不互斥

线程3 线程4 cpu可同时进入a和c中进行替换

| |

------------------------------- 用什么进行互斥分组？就是synchronized中的obj

c……… d…… 值不同，而分为不同的互斥组。

04. 传统线程同步通信技术

5、wait与notify实现线程间的通信；

用面试宝典中的子线程循环10次和主线程循环5次，两者交替运行50的例子讲解；

为了观察程序的运行结果，可以在eclipse中设置运行对话框，让结果重定向到一个文本文件，然后用UE去查看该文件中的特殊的行号处是否正好对应了线程的切换点；

经验：要用到共同数据（包括同步锁）或同步算法的若干个方法应该归在同一个类身上，这种设计正好体现了高类聚和程序的健壮性。

package cn.itcast.heima;

/**

* 面试题：子线程循环10次，接着主线程循环10次；

* 接着又回到子线程循环10次，然后再让主线程循环10此。

* 交替循环50次

* @author Administrator

publicclass TraditionalThreadCommunication

{

publicstaticvoid main(String[] args)

{

final Business business =new Business(); //为什么要加final

//子线程

new Thread(new Runnable(){

publicvoid run()

{

for(int i=1;i<=50;i++)

{

business.sub(i); //每次循环，执行十次，然后等待唤醒main

}

}).start();

for(int i=1;i<=50;i++)

{

business.main(i);

}

//此处不加static，在main方法中new内部类对象会出错，

//是为什么？因为静态只能访问静态？

staticclass Business

{

privatebooleanbShouldSub =true;

publicsynchronizedvoid sub(int i)

{

while(!bShouldSub) //不该子线程运行了就让子线程等

{

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

for(int j=1;j<=10;j++)

{

System.out.println("sub Thread sequece of"+j+"，loop of "+i);

}

bShouldSub=false;

this.notify(); //唤醒主线程

}

publicsynchronizedvoid main(int i)

{

while(bShouldSub)

{

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

for(int j=1;j<=20;j++)

{

System.out.println("main Thread "+j+"，loop of "+i);

}

bShouldSub=true;

this.notify(); //唤醒子线程

}

05. 线程范围内共享变量的概念与作用

publicclass ThreadScopeShareData

{

//存放线程和数据的映射关系

privatestatic Map<Thread, Integer>threadData =new HashMap<Thread, Integer>();

publicstaticvoid main(String[] args)

{

for(int i=0;i<2;i++) //产生两个线程

{

new Thread(new Runnable(){

publicvoid run()

{

int data =new Random().nextInt();

System.out.println(Thread.currentThread().getName()+" get data "+data);

threadData.put(Thread.currentThread(), data);

new A().get();

new B().get();

}

}).start();

}

06. ThreadLocal类及应用技巧

ThreadLocal实现线程范围的共享变量：

1、每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map中增加一条记录，key分别是各自的线程，value是各自的set方法传进去的值。在线程结束时可以调用ThreadLocal.clear()方法，这样会更块释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

2、ThreadLocal的应用场景：

订单处理包一系列操作：减少库存量、增加一条流水台账、修改总账，这几个操作要在一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败，则应该把前面的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码分别位于不同的模块类中；

银行转账包含一系列操作：把转出账户的余额减少，把转入账户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库对象，转入和转出操作的代码分别是两个不同的账户对象的方法。

例如Strut2的ActionContext，同一段代码被不同的线程调用运行的，该代码操作的数据是每个线程各自的状态和数据，对于不同的线程来说，getContext方法拿到的对象都不相同，对同一个线程来说，不管调用getContext方法多少次和在那个模块中getContext方法，拿到的都是同一个。

实例：

publicclass ThreadLocalTest

{

//定义一个全局变量的ThreaadLocal变量,只能存放一个数据

privatestatic ThreadLocal<Integer> x =new ThreadLocal<Integer>();

//定义一个全局变量的ThreaadLocal变量，存放一个对象，线程的所有数据封装在这个对象中

privatestatic ThreadLocal<MyThreadScopeData> myThreadScopeData =

new ThreadLocal<MyThreadScopeData>();

publicstaticvoid main(String[] args)

{

for(int i=0;i<2;i++) //产生两个线程

{

new Thread(new Runnable(){

publicvoid run()

{

int data =new Random().nextInt();

System.out.println(Thread.currentThread().getName()+" get data "+data);

x.set(data); //向ThreadLocal变量x中存储一个随机值

MyThreadScopeData.getThreadInstance().setName("name"+data);

MyThreadScopeData.getThreadInstance().setAge(data);

//调用其他类的方法，获取x的值，多个类在同一线程中获取到的值是相同的

new A().get();

new B().get();

}

}).start();

}

staticclass A

{

publicvoid get()

{

//读取这个ThreadLocal变量的值

int data =x.get();

System.out.println("A from "+Thread.currentThread().getName()+" get data: "+data);

MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();

System.out.println("A from "+Thread.currentThread().getName()

+" getMyData: "+ myData.getName()+"，"+myData.getAge());

}

staticclass B

{

publicvoid get()

{

int data =x.get();

System.out.println("B from "+Thread.currentThread().getName()+" get data: "+data);

MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();

System.out.println("B from "+Thread.currentThread().getName()

+" getMyData: "+ myData.getName()+"，"+myData.getAge());

}

//将线程的局部变量封装成对象，这样ThreadLocal中存放一个对象就等于存了几个数据

staticclass MyThreadScopeData

{

//单例设计模式

private MyThreadScopeData(){}

publicstatic/*synchronized*/ MyThreadScopeData getThreadInstance()

{

MyThreadScopeData instance =map.get();

if(instance ==null)

{

instance =new MyThreadScopeData();

map.set(instance);

}

return instance;

}

//private static MyThreadScopeData instance = null;

privatestatic ThreadLocal<MyThreadScopeData>map =

new ThreadLocal<MyThreadScopeData>();

private Stringname;

privateintage;

public String getName() {

returnname;

}

publicvoid setName(String name) {

this.name = name;

}

publicint getAge() {

returnage;

}

publicvoid setAge(int age) {

this.age = age;

}

07. 多个线程之间共享数据的方式探讨

1、如果每个线程执行的代码相同，可使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就可以这么做。

2、如果每个线程执行的代码不同，这时就需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：

A、将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象，每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。

B、将这些Runnable对象作为某个类中的内部类，共享数据作为这个外部类中的成员变量。每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥通信，作为内部类的各个Runnable对象调用外部类的这些方法。

C、上面两种方式的组合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。

总之，要同步互斥的几段代码最好是分别在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现他们之间的同步互斥和通信。

08. java5原子性操作类的应用

1、了解java.util.concurrent.atomic包；

看atomic包文档页下面的介绍，可以对基本数据AtomicInteger，对数组中的基本数据AtomicIntegerArray，对类中的基本数据AtomicIntegerFieldUpdater等进行操作。

09. java5线程并发库的应用

Java5中的线程并发库：
2、看java.util.concurrent包及子包的API帮助文档；

看concurrent包的帮助文档，对并发库中涉及的内容有一个总体上的介绍。
类Executors

此包中所定义的Executor、ExecutorService、ScheduledExecutorService、ThreadFactory和Callable类的工厂和实用方法

3、了解java.util.concurrent.lock包

线程池：

线程池的概念与Executors类的应用

A、理解：在线程池编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池拿到任务后，它就在内部招有无空闲的线程，再把任务交给内部某个空闲线程，这就是封装。记住，任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池中提交多个任务。

B、创建固定大小的线程池：

ExecutorService threadPool = Executors.newFixedThreadPool(3);

创建缓存线程池：

ExecutorService threadPool = Executors.newCachedThreadPool();

创建单一线程池：（如何实现线程死掉后重新启动一个线程）

ExecutorService threadPool = Executors.newSingleThreadExecutor();

C、关闭线程池：

void	shutdown() 启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
List<Runnable>	shutdownNow() 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。

D、用线程池启动定时器：

调用ScheduleExecutorService的schedule方法，返回的SchedulFuture对象可以取消任务。

支持间隔重复任务的定时方式，不直接支持绝对定时方式，需要转换成相对时间方式。

实例：

Executors.newScheduledThreadPool(3).scheduleAtFixedRate(

new Runnable(){@Override

publicvoid run() {

System.out.println(Thread.currentThread()+" bombing!");

//Thread[pool-2-thread-1,5,main] bombing!

}},

1, //10秒后炸

2, //以后每隔2秒炸一次

TimeUnit.SECONDS);

10. Callable与Future的应用

java.util.concurrent

接口 Callable<V>

返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做call 的方法。Callable 接口类似于Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是Runnable 不会返回结果，并且无法抛出经过检查的异常。
接口 Future<V>表示异步计算的结果

//创建线程池

ExecutorService threadPool2 = Executors.newSingleThreadExecutor(); CompletionService<Integer> completionService =

new ExecutorCompletionService(threadPool2);

for(int i=1;i<=10;i++) //提交10个任务，任务会返回结果

{

finalint seq = i;

completionService.submit(new Callable<Integer>() {

public Integer call()throws Exception {

Thread.sleep(new Random().nextInt(5000));//等待5秒以内随机

return seq;

}

});

}

//获取任务执行结果

for(int i=0;i<10;i++)

{

try {

//获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。

System.out.println(completionService.take().get());

} catch (Exception e) {

e.printStackTrace();

}

11. java5的线程锁技术

java.util.concurrent.locks
接口 LockLock

实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

锁本身也应该是一个对象，两个线程执行的代码片段要实现同步互斥，他们必须使用用一个Lock对象。锁是上在代表要操作的资源的类的内部方法中，而不是线程代码中。

接口 Condition

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。