Java多线程和并发编程实践的学习心得----基础篇2

Java多线程和并发编程实践的学习心得----基础篇2

二  java多线程的基本调度和简单同步

1、线程的基本调度

线程调度是指系统为线程分配处理器使用权的过程：协同式、抢占式。

协同式：线程的执行时间由线程本身控制，线程把自己的工作执行完了之后，要主动通知系统切换到另一个线程上。  坏处：线程执行时间不可控制。

抢占式：每个线程将由系统来分配执行时间，线程的切换不由线程本身来决定。Java使用该种调用方式。

线程优先级：在一些平台上(操作系统线程优先级比Java线程优先级少)不同的优先级实际会变得相同；优先级可能会被系统自行改变。

线程的基本调度主要还是依靠Java线程类 中常用的方法；如 sleep(),Join(),yield()，setPriority()等方法以及和Object类中的wait(),notify(),notifyAll()等方法。
        
线程休眠sleep()：顾名思义，线程休眠的目的是使线程让出CPU的最简单的做法之一，线程休眠时候，会将CPU资源交给其他线程，以便能轮换执行，当休眠一定时间后，线程会苏醒，进入准备状态等待执行。线程休眠的方法是Thread.sleep(long millis) 和Thread.sleep(long millis, int nanos) ，均为静态方法，哪个线程调用sleep，就休眠哪个线程。

线程优先级setPriority()：优先级高的线程获取CPU资源的概率较大，优先级低的并非没机会执行。线程的优先级用1-10之间的整数表示，数值越大优先级越高，默认的优先级为5。子线程初始优先级与父线程相同。
线程的让步含义就是使当前运行着线程让出CPU资源，但是然给谁不知道，仅仅是让出，线程状态回到可运行状态。
 

线程的让步yield()：线程的让步使用Thread.yield()方法，yield() 为静态方法，功能是暂停当前正在执行的线程对象，并执行其他线程。

线程的合并join():   线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时可以使用join方法。

Object.wait() :显而易见，这个和上面方法的区别了。这个方法的Java中的超类Object的静态方法之一。效果是让当前对象所在的线程进入等待状态，就是停在那里，一值傻等着，啥也不干，就像睡着了，但不能自己醒来，必须由其他线程来叫醒。

Object.notify/Object.notifyAll() ：和wait()方法一样，该方法也Object的。作用就是叫醒wait()方法所在的线程。其中，Object.notify()是叫醒一个线程，显然Object.notityAll()是叫醒所有线程，但是还是不能叫醒自己所在的线程。

  

2、线程的同步

首先来搞清楚一个很重要的问题：线程的同步是什么？

这回不能顾名思义了。线程的同步并不是多个线程同意时间同时访问资源，恰恰相反，线程同步的真实含义是“排队”，多线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。 

关于线程同步，需要明白一下几点：

• 1 线程同步就是线程排队。同步就是“排队”。线程同步的目的就是避免线程“同步”执行。
• 2 “共享”  ：  只有共享资源的读写访问才需要同步。如果不是共享资源，那么就根本没有同步的必要。 
• 3 “变量”：    只有“变量”才需要同步访问。如果共享的资源是固定不变的，那么就相当于“常量”，线程同时读取常量也不需要同步。至少一个线程修改共享资源，这样的情况下，线程之间就需要同步。
• 4  同步： 多个线程访问共享资源的代码有可能是同一份代码，也有可能是不同的代码；无论是否执行同一份代码，只要这些线程的代码访问同一份可变的共享资源，这些线程之间就需要同步。

如何才能线程同步？

线程同步的基本实现思路还是比较容易理解的。我们可以给共享资源加一把锁，这把锁只有一把钥匙。哪个线程获取了这把钥匙，才有权利访问该共享资源。这把钥匙在Java中就是线程同步锁。

那么问题来了：同步锁应该加在哪里？

尽量把同步锁加在共享资源上。同步锁应该加在操作共享对象资源的代码段上的。

在操作系统中，比如，文件系统，数据库系统等，自身都提供了比较完善的同步锁机制。我们不用另外给这些资源加锁，这些资源自己就有锁。 

但是最重要的问题来了，应该加什么样的锁？

首先我么知道访问同一份共享资源的不同代码段，应该加上同一个同步锁；如果加的是不同的同步锁，那么根本就起不到同步的作用，没有任何意义。
同时：同步锁本身也一定是多个线程之间的共享对象。 

synchronized关键字：

Java语言里面用synchronized关键字给代码段加锁。相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 。

整个语法形式表现为 ：
synchronized(同步锁) {
  // 访问共享资源，需要同步的代码段
}
这里尤其要注意的就是，同步锁本身一定要是共享的对象。

volatite 关键字：

Java 语言提供了一种稍弱的同步机制,即 volatile 变量.用来确保将变量的更新操作通知到其他线程,保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新. 当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的.

简单一点说：Volatile就是通知编译器和运行时注意下自己声明过的变量，这个变量是线程共享的。

synchronized 和volatie的区别和具体用法将在下一节说明！

3 消费者与生产者模型

对于并发协助的多线程的模型来说，“生产者-消费者-仓储”模型是经典的模型，没有之一。很多时候都简称为：
生产者和消费者模型。

对于此经典模型，应该知道一下4点：

• 1、生产者仅仅在仓储未满时候生产，仓满则停止生产。
• 2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。
• 3、当消费者发现仓储没产品可消费时候会通知生产者生产。
• 4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。
   

实现此模型就要使用上面讲的线程的基本调度(如wait(),notityAll()等）和简单同步（synchronized关键字）中的方法了，正好来实践一下：

package com.qyl.dome1;

public class ProducerConsumer {
	public static void main(String[] args) {
		SyncStack ss = new SyncStack();
		Producer p = new Producer(ss);
		Consumer c = new Consumer(ss);
		new Thread(p).start();
		//new Thread(p).start();
		//new Thread(p).start();
		new Thread(c).start();
	}
}

class Apple {
	int id; 
	Apple(int id) {
		this.id = id;
	}
	public String toString() {
		return "Apple : " + id;
	}
}

class SyncStack {
	int index = 0;
	Apple[] arrapple = new Apple[6];
	
	public synchronized void push(Apple apple) {
		while(index == arrapple.length) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();		
		arrapple[index] = apple;
		index ++;
	}
	
	public synchronized Apple pop() {
		while(index == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.notifyAll();
		index--;
		return arrapple[index];
	}
}

class Producer implements Runnable {
	SyncStack ss = null;
	Producer(SyncStack ss) {
		this.ss = ss;
	}
	
	public void run() {
		for(int i=1; i<20; i++) {
			Apple apple = new Apple(i);
			ss.push(apple);
			System.out.println("生产了：" + apple);
			try {
				Thread.sleep((int)(Math.random() * 200));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}			
		}
	}
}

class Consumer implements Runnable {
	SyncStack ss = null;
	Consumer(SyncStack ss) {
		this.ss = ss;
	}
	
	public void run() {
		for(int i=1; i<20; i++) {
			Apple apple = ss.pop();
			System.out.println("消费了: " + apple);
			try {
				Thread.sleep((int)(Math.random() * 1000));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}			
		}
	}
}

上面的例子中：Apple是商品，SyncStack是仓库，Consumer是消费者，Producer是生产者，他们协作共同完成生产和消费的供应链。

程序执行结果如下：

生产了：Apple : 1
消费了: Apple : 1
生产了：Apple : 2
消费了: Apple : 2
生产了：Apple : 3
生产了：Apple : 4
生产了：Apple : 5
生产了：Apple : 6
消费了: Apple : 6
生产了：Apple : 7
生产了：Apple : 8
生产了：Apple : 9
消费了: Apple : 9
生产了：Apple : 10
生产了：Apple : 11
消费了: Apple : 10
消费了: Apple : 11
生产了：Apple : 12
消费了: Apple : 12
生产了：Apple : 13
消费了: Apple : 13
生产了：Apple : 14
消费了: Apple : 14
生产了：Apple : 15
消费了: Apple : 15
生产了：Apple : 16
生产了：Apple : 17
消费了: Apple : 16
生产了：Apple : 18
消费了: Apple : 17
消费了: Apple : 18
生产了：Apple : 19
消费了: Apple : 19

 未完待续.......

在下一篇中将会比较深入的探讨线程同步中的有关术语和概念。