java高级之多线程(二)

多线程的第二篇文章，两个线程之间的通信就不写了，主要写写多个线程之间的通信和几个简单的设计模式吧。

一：多个线程的通信

以前的多线程之间的通信用wait()方法和while循环，配上notifyAll()方法，在jdk1.5的时候有了新改动，

同步：使用ReentrantLock的lock()和unlock()方法进行同步。

通信：使用ReentrantLock的newCondition()方法获取不同的condition对象，await()方法等待，signal唤醒指定的线程。

await后，后面的代码会暂时不执行（阻塞），直到有调用signal方法唤醒。

package S2;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.ReentrantLock;public class NotifyDemo2 {/** * 等待 唤醒机制。 *  * @param args */public static void main(String[] args) {final Printer2 p = new Printer2();new Thread() {public void run() {while (true) {try {p.print1();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}.start();new Thread() {public void run() {while (true) {try {p.print2();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}.start();new Thread() {public void run() {while (true) {try {p.print3();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}.start();}}/** * wait方法可以传入参数也可以不传入 wait方法和sleep方法的区别就是 sleep方法在同步方法代码块中 不释放锁睡着了也抱着， * wait方法在同步方法和同步代码块中 释放锁。 *  * @author xiaoning * */class Printer2 {private ReentrantLock r = new ReentrantLock();private Condition c1 = r.newCondition();private Condition c2 = r.newCondition();private Condition c3 = r.newCondition();// 如果if换成while循环 所有线程都会进入等待状态 什么对象当做锁就用什么对象调用 wait notify方法private int is = 1;public void print1() throws Exception {r.lock(); // 获取锁if (is != 1) { // 最后 没有满足if条件 执行后面的字 之后is=2  唤醒2， 2会直接输出后面的字，

                                 // 同样的道理 is=3  3会直接醒来输出后面的字在while循环所以会不停打印c1.await();}System.out.print("人");System.out.print("间");System.out.print("天");System.out.print("堂");System.out.print("\r\n");is = 2;c2.signal();r.unlock(); // 释放锁}public void print2() throws Exception {r.lock();if (is != 2) { // 例子： 假设首先2 ！= 1 线程2 在此等待c2.await();}System.out.print("十八");System.out.print("层");System.out.print("地");System.out.print("狱");System.out.print("\r\n");is = 3;c3.signal();r.unlock();}public void print3() throws Exception {r.lock();if (is != 3) { // 其次 线程 3！= 1 线程2 在此等待c3.await(); // if循环是在哪等待就在哪起来// while循环是循环判断 每次都会判断标记== ？}System.out.print("深");System.out.print("山");System.out.print("老");System.out.print("林");System.out.print("\r\n");is = 1;c1.signal(); // 唤醒指定的线程r.unlock();}}

运行结果：

一：简单的几个设计模式

(1) 单例模式：

package S2;public class SingleDemo {public static void main(String[] args) {Singledemo s1 = Singledemo.getIntence();}}/** * 恶汉式 单例  耗费空间节省时间 * @author xiaoning * *//*class Singledemo {private Singledemo() {// 私有构造方法，其他类不能访问}private static Singledemo s = new Singledemo();public static Singledemo getIntence() {return s;}}*//** * 懒汉式单例    耗费时间 节省空间 * @author xiaoning * */class Singledemo {private Singledemo() {// 私有构造方法，其他类不能访问}private static Singledemo s;public static Singledemo getIntence() {           if(s==null){//不好 容易创建多个对象，当线程一进来了，执行权被线程二抢去了，线程二也进来了。。。。之后创建了多个对象           s = new Singledemo();                      }return s;}}/** * 懒汉式是时间换空间，恶汉式是空间换时间 * 在多线程模式中，懒汉式可能会创建多个对象，恶汉式不会创建多个对象。 *  public static final Singledemo s ; */

(2)适配器模式：

package S2;public class AdapterDemo {/** 什么·是适配器？ 在用监听器的时候 需要自定义一个事件监听接口， 监听器有很多方法， * 有时候实现接口这么多方法，只需要重写用到的方法 此时用到适配器设计模式 * 适配器原理：是实现了监听器的接口，重写了所有方法，但是空的 ，定义监听器只需要重写其适配器的有用防范就行了 * 适配器设计模式  继承适配器，重写方法 * 事件：用户的操作 * 事件源：被操作的组件 */public static void main(String[] args) {dog d = new dog();d.run();}}interface animal{  public abstract void say();  public abstract void walk();  public abstract void run();  } abstract class  animalson implements animal{ //abstract 不让其他类创建对象，创建也没有意义 ，方法都是空的 过渡@Overridepublic void say() {// TODO Auto-generated method stub}@Overridepublic void walk() {// TODO Auto-generated method stub}@Overridepublic void run() {// TODO Auto-generated method stub}}  class  dog extends animalson{ //想重写那个方法就重写那个方法 @Overridepublic void run() {super.run();System.out.println("狗在跑。。。。。。");}    }  

()3工厂模式：

工厂方法模式概述
* 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
* B:优点
* 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
* C:缺点
* 需要额外的编写代码，增加了工作量
* D:案例演示
* 
动物抽象类：public abstract Animal { public abstract void eat(); }
工厂接口：public interface Factory {public abstract Animal createAnimal();}
具体狗类：public class Dog extends Animal {}
具体猫类：public class Cat extends Animal {}
开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。发现每次修改代码太麻烦，用工厂方法改进，针对每一个具体的实现提供一个具体工厂。
狗工厂：public class DogFactory implements Factory {
public Animal createAnimal() {…}
       }
猫工厂：public class CatFactory implements Factory {
public Animal createAnimal() {…}