java多线程 并发 编程

转自:http://www.cnblogs.com/luxiaoxun/p/3870265.html

一、多线程的优缺点

多线程的优点:

1)资源利用率更好 2)程序设计在某些情况下更简单 3)程序响应更快

多线程的代价:

1)设计更复杂 虽然有一些多线程应用程序比单线程的应用程序要简单,但其他的一般都更复杂。在多线程访问共享数据的时候,这部分代码需要特别的注意。线程之间的交互往往非常复杂。不正确的线程同步产生的错误非常难以被发现,并且重现以修复。

2)上下文切换的开销 当CPU从执行一个线程切换到执行另外一个线程的时候,它需要先存储当前线程的本地的数据,程序指针等,然后载入另一个线程的本地数据,程序指针等,最后才开始执行。这种切换称为“上下文切换”(“context switch”)。CPU会在一个上下文中执行一个线程,然后切换到另外一个上下文中执行另外一个线程。上下文切换并不廉价。如果没有必要,应该减少上下文切换的发生。

二、创建java多线程

1、创建Thread的子类

创建Thread子类的一个实例并重写run方法,run方法会在调用start()方法之后被执行。例子如下:

1 public class MyThread extends Thread {
2    public void run(){
3      System.out.println("MyThread running");
4    }
5 }
6
7 MyThread myThread = new MyThread();
8 myTread.start();

也可以如下创建一个Thread的匿名子类:

1 Thread thread = new Thread(){
2    public void run(){
3      System.out.println("Thread Running");
4    }
5 };
6 thread.start();

2、实现Runnable接口

第二种编写线程执行代码的方式是新建一个实现了java.lang.Runnable接口的类的实例,实例中的方法可以被线程调用。下面给出例子:

1 public class MyRunnable implements Runnable {
2    public void run(){
3     System.out.println("MyRunnable running");
4    }
5 }
6
7 Thread thread = new Thread(new MyRunnable());
8 thread.start();

同样,也可以创建一个实现了Runnable接口的匿名类,如下所示:

1 Runnable myRunnable = new Runnable(){
2    public void run(){
3      System.out.println("Runnable running");
4    }
5 }
6 Thread thread = new Thread(myRunnable);
7 thread.start();

三、线程安全

在同一程序中运行多个线程本身不会导致问题,问题在于多个线程访问了相同的资源。如同一内存区(变量,数组,或对象)、系统(数据库,web services等)或文件。实际上,这些问题只有在一或多个线程向这些资源做了写操作时才有可能发生,只要资源没有发生变化,多个线程读取相同的资源就是安全的。

当两个线程竞争同一资源时,如果对资源的访问顺序敏感,就称存在竞态条件。导致竞态条件发生的代码区称作临界区。

如果一个资源的创建,使用,销毁都在同一个线程内完成,且永远不会脱离该线程的控制,则该资源的使用就是线程安全的。

四、java同步块

Java中的同步块用synchronized标记。同步块在Java中是同步在某个对象上。所有同步在一个对象上的同步块在同时只能被一个线程进入并执行操作。所有其他等待进入该同步块的线程将被阻塞,直到执行该同步块中的线程退出。

有四种不同的同步块:

  1. 实例方法
  2. 静态方法
  3. 实例方法中的同步块
  4. 静态方法中的同步块

实例方法同步:

1 public synchronized void add(int value){
2 this.count += value;
3  }

Java实例方法同步是同步在拥有该方法的对象上。这样,每个实例其方法同步都同步在不同的对象上,即该方法所属的实例。只有一个线程能够在实例方法同步块中运行。如果有多个实例存在,那么一个线程一次可以在一个实例同步块中执行操作。一个实例一个线程。

静态方法同步:

1 public static synchronized void add(int value){
2  count += value;
3  }

静态方法的同步是指同步在该方法所在的类对象上。因为在Java虚拟机中一个类只能对应一个类对象,所以同时只允许一个线程执行同一个类中的静态同步方法。

实例方法中的同步块:

1 public void add(int value){
2     synchronized(this){
3        this.count += value;
4     }
5   }

注意Java同步块构造器用括号将对象括起来。在上例中,使用了“this”,即为调用add方法的实例本身。在同步构造器中用括号括起来的对象叫做监视器对象。上述代码使用监视器对象同步,同步实例方法使用调用方法本身的实例作为监视器对象。一次只有一个线程能够在同步于同一个监视器对象的Java方法内执行。

下面两个例子都同步他们所调用的实例对象上,因此他们在同步的执行效果上是等效的。

 1 public class MyClass {
 2
 3    public synchronized void log1(String msg1, String msg2){
 4       log.writeln(msg1);
 5       log.writeln(msg2);
 6    }
 7
 8    public void log2(String msg1, String msg2){
 9       synchronized(this){
10          log.writeln(msg1);
11          log.writeln(msg2);
12       }
13    }
14  }

静态方法中的同步块:

 1 public class MyClass {
 2     public static synchronized void log1(String msg1, String msg2){
 3        log.writeln(msg1);
 4        log.writeln(msg2);
 5     }
 6
 7     public static void log2(String msg1, String msg2){
 8        synchronized(MyClass.class){
 9           log.writeln(msg1);
10           log.writeln(msg2);
11        }
12     }
13   }

这两个方法不允许同时被线程访问。如果第二个同步块不是同步在MyClass.class这个对象上。那么这两个方法可以同时被线程访问。

五、java线程通信

线程通信的目标是使线程间能够互相发送信号。另一方面,线程通信使线程能够等待其他线程的信号。

Java有一个内建的等待机制来允许线程在等待信号的时候变为非运行状态。java.lang.Object 类定义了三个方法,wait()、notify()和notifyAll()来实现这个等待机制。

一个线程一旦调用了任意对象的wait()方法,就会变为非运行状态,直到另一个线程调用了同一个对象的notify()方法。为了调用wait()或者notify(),线程必须先获得那个对象的锁。也就是说,线程必须在同步块里调用wait()或者notify()。

以下为一个使用了wait()和notify()实现的线程间通信的共享对象:

 1 public class MyWaitNotify{
 2
 3   MonitorObject myMonitorObject = new MonitorObject();
 4   boolean wasSignalled = false;
 5
 6   public void doWait(){
 7     synchronized(myMonitorObject){
 8       while(!wasSignalled){
 9         try{
10           myMonitorObject.wait();
11          } catch(InterruptedException e){...}
12       }
13       //clear signal and continue running.
14       wasSignalled = false;
15     }
16   }
17
18   public void doNotify(){
19     synchronized(myMonitorObject){
20       wasSignalled = true;
21       myMonitorObject.notify();
22     }
23   }
24 }

注意以下几点:

1、不管是等待线程还是唤醒线程都在同步块里调用wait()和notify()。这是强制性的!一个线程如果没有持有对象锁,将不能调用wait(),notify()或者notifyAll()。否则,会抛出IllegalMonitorStateException异常。

2、一旦线程调用了wait()方法,它就释放了所持有的监视器对象上的锁。这将允许其他线程也可以调用wait()或者notify()。

3、为了避免丢失信号,必须把它们保存在信号类里。如上面的wasSignalled变量。

4、假唤醒:由于莫名其妙的原因,线程有可能在没有调用过notify()和notifyAll()的情况下醒来。这就是所谓的假唤醒(spurious wakeups)。为了防止假唤醒,保存信号的成员变量将在一个while循环里接受检查,而不是在if表达式里。这样的一个while循环叫做自旋锁。

5、不要在字符串常量或全局对象中调用wait()。即上面MonitorObject不能是字符串常量或是全局对象。每一个MyWaitNotify的实例都拥有一个属于自己的监视器对象,而不是在空字符串上调用wait()/notify()。

六、java中的锁

自Java 5开始,java.util.concurrent.locks包中包含了一些锁的实现,因此你不用去实现自己的锁了。

常用的一些锁:

java.util.concurrent.locks.Lock; java.util.concurrent.locks.ReentrantLock; java.util.concurrent.locks.ReadWriteLock; java.util.concurrent.locks.ReentrantReadWriteLock;

一个可重入锁(reentrant lock)的简单实现:

 1 public class Lock {
 2     boolean isLocked = false;
 3     Thread  lockedBy = null;
 4     int lockedCount = 0;
 5
 6     public synchronized void lock() throws InterruptedException{
 7         Thread callingThread = Thread.currentThread();
 8         while(isLocked && lockedBy != callingThread){
 9             wait();
10         }
11         isLocked = true;
12         lockedCount++;
13         lockedBy = callingThread;
14     }
15
16     public synchronized void unlock(){
17         if(Thread.currentThread() == this.lockedBy){
18             lockedCount--;
19             if(lockedCount == 0){
20                 isLocked = false;
21                 notify();
22             }
23         }
24     }
25 }

注意的一点:在finally语句中调用unlock()

1 lock.lock();
2 try{
3     //do critical section code, which may throw exception
4 } finally {
5     lock.unlock();
6 }

七、java中其他同步方法

信号量(Semaphore):java.util.concurrent.Semaphore

阻塞队列(Blocking Queue):java.util.concurrent.BlockingQueue

 1 public class BlockingQueue {
 2     private List queue = new LinkedList();
 3     private int limit = 10;
 4
 5     public BlockingQueue(int limit) {
 6         this.limit = limit;
 7     }
 8
 9     public synchronized void enqueue(Object item) throws InterruptedException {
10         while (this.queue.size() == this.limit) {
11             wait();
12         }
13         if (this.queue.size() == 0) {
14             notifyAll();
15         }
16         this.queue.add(item);
17     }
18
19     public synchronized Object dequeue() throws InterruptedException {
20         while (this.queue.size() == 0) {
21             wait();
22         }
23         if (this.queue.size() == this.limit) {
24             notifyAll();
25         }
26         return this.queue.remove(0);
27     }
28 }

八、java中的线程池

Java通过Executors提供四种线程池,分别为:

newCachedThreadPool

创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。

newFixedThreadPool

创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。

newScheduledThreadPool

创建一个大小无限制的线程池。此线程池支持定时以及周期性执行任务。

newSingleThreadExecutor

创建一个单线程的线程池。此线程池支持定时以及周期性执行任务。这个线程池只有一个线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

线程池简单用法:

 1 import java.util.concurrent.ExecutorService;
 2 import java.util.concurrent.Executors;
 3
 4 public class Main {
 5     public static void main(String[] args) {
 6         ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
 7         for (int i = 0; i < 10; i++) {
 8             final int index = i;
 9             cachedThreadPool.execute(new Runnable() {
10                 public void run() {
11                     System.out.println(index);
12                 }
13             });
14         }
15     }
16 }

时间: 02-14

java多线程 并发 编程的相关文章

对JAVA多线程 并发编程的理解

对JAVA多线程并发编程的理解 Java多线程编程关注的焦点主要是对单一资源的并发访问,本文从Java如何实现支持并发访问的角度,浅析对并发编程的理解,也算是对前段时间所学的一个总结. 线程状态转换 Java语言定义了5中线程状态,在任何一个时间点,一个线程只能有且只有其中一种状态,这5中状态分别是: ?  新建(New):创建后尚未启动的线程处于这种状态 ?  运行(Runable):Runable包括了操作系统线程状态中的Running和Ready,也就是处于此状态的线程可能正在执行,也有可

java多线程并发编程与CPU时钟分配小议

我们先来研究下JAVA的多线程的并发编程和CPU时钟振荡的关系吧 老规矩,先科普 我们的操作系统在DOS以前都是单任务的 什么是单任务呢?就是一次只能做一件事 你复制文件的时候,就不能重命名了 那么现在的操作系统,我一边在这边写BLOG,一边听歌,一边开着QQ,一边…………………… 显然,现在的操作系统都是多任务的操作系统 操作系统对多任务的支持是怎么样的呢? 每打开一个程序,就启动一个进程,为其分配相应空间(主要是运行程序的内存空间) 这其实就支持并发运行了 CPU有个时钟频率,表示每秒能执行

Java多线程并发编程

Thread和Runnable Runnable接口可以避免继承自Thread类的单继承的局限性. Runnable的代码可以被多个线程(Thread的实例)所共享,适合于多个线程共享资源(其实就是持有同一个runnable实例)的情况. 以火车站买票为例,分别以继承Thread类和实现Runnable接口这两种方式来模拟3个线程卖5张票: 使用Thread类模拟卖票 1 class MyThread extends Thread{ 2 3 private int ticketCount = 5

Java 多线程 并发编程 (转)

一.多线程 1.操作系统有两个容易混淆的概念,进程和线程. 进程:一个计算机程序的运行实例,包含了需要执行的指令:有自己的独立地址空间,包含程序内容和数据:不同进程的地址空间是互相隔离的:进程拥有各种资源和状态信息,包括打开的文件.子进程和信号处理. 线程:表示程序的执行流程,是CPU调度执行的基本单位:线程有自己的程序计数器.寄存器.堆栈和帧.同一进程中的线程共用相同的地址空间,同时共享进进程锁拥有的内存和其他资源. 2.Java标准库提供了进程和线程相关的API,进程主要包括表示进程的jav

Java 多线程 并发编程

转自: http://blog.csdn.net/escaflone/article/details/10418651 一.多线程 1.操作系统有两个容易混淆的概念,进程和线程. 进程:一个计算机程序的运行实例,包含了需要执行的指令:有自己的独立地址空间,包含程序内容和数据:不同进程的地址空间是互相隔离的:进程拥有各种资源和状态信息,包括打开的文件.子进程和信号处理. 线程:表示程序的执行流程,是CPU调度执行的基本单位:线程有自己的程序计数器.寄存器.堆栈和帧.同一进程中的线程共用相同的地址空

多线程并发编程

前言 多线程并发编程是Java编程中重要的一块内容,也是面试重点覆盖区域,所以学好多线程并发编程对我们来说极其重要,下面跟我一起开启本次的学习之旅吧. 正文 线程与进程 1 线程:进程中负责程序执行的执行单元线程本身依靠程序进行运行线程是程序中的顺序控制流,只能使用分配给程序的资源和环境 2 进程:执行中的程序一个进程至少包含一个线程 3 单线程:程序中只存在一个线程,实际上主方法就是一个主线程 4 多线程:在一个程序中运行多个任务目的是更好地使用CPU资源 线程的实现 继承Thread类 在j

java 多线程并发问题总结

java 多线程并发主要通过关键字synchronized实现 Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码. 一.当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行.另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块. 二.然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该ob

《Java虚拟机并发编程》学习笔记

对<Java虚拟机并发编程>这本书真的是相见恨晚.以前对并发编程只是懂个皮毛,这本书让我对并发编程有了一个全新的认识.所以把书上的知识点做下笔记,以便以后复习使用. 并发与并行 仔细说来,并发和并行是两个不同的概念.但随着多核处理器的普及,并发程序的不同的线程往往会被编译器分配到不同处理器核心上,所以说并发编程与并行对于上层程序员来说是一样的. 并发的风险 饥饿 当一个线程等待某个需要运行时间很长或者永远无法完成的时间发发生,那么这个线程就会陷入饥饿状态.通常饥饿也会被叫做活锁. 解决饥饿的方

Java多线程并发技术

Java多线程并发技术 参考文献: http://blog.csdn.net/aboy123/article/details/38307539 http://blog.csdn.net/ghsau/article/category/1707779 http://www.iteye.com/topic/366591 JAVA多线程实现方式主要有三种:继承Thread类.实现Runnable接口.使用ExecutorService.Callable.Future实现有返回结果的多线程.其中前两种方式