Java学习之线程(二)

###25.01_多线程(单例设计模式)(掌握)

单例设计模式：保证类在内存中只有一个对象。
如何保证类在内存中只有一个对象呢？
- (1)控制类的创建，不让其他类来创建本类的对象。private
- (2)在本类中定义一个本类的对象。Singleton s;
- (3)提供公共的访问方式。 public static Singleton getInstance(){return s}

单例写法两种：

(1)饿汉式开发用这种方式。

  //饿汉式 
  class Singleton {
  	//1,私有构造函数
  	private Singleton(){}
  	//2,创建本类对象
  	private static Singleton s = new Singleton();
  	//3,对外提供公共的访问方法
  	public static Singleton getInstance() {
  		return s;
  	}
  	
  	public static void print() {
  		System.out.println("11111111111");
  	}
  }

(2)懒汉式面试写这种方式。多线程的问题？

  //懒汉式,单例的延迟加载模式
  class Singleton {
  	//1,私有构造函数
  	private Singleton(){}
  	//2,声明一个本类的引用
  	private static Singleton s;
  	//3,对外提供公共的访问方法
  	public static Singleton getInstance() {
  		if(s == null)
  			//线程1,线程2
  			s = new Singleton();
  		return s;
  	}
  	
  	public static void print() {
  		System.out.println("11111111111");
  	}
  }

(3)第三种格式

  class Singleton {
  	private Singleton() {}
  
  	public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
  }

饿汉式懒汉式的区别
饿汉式第一次启动时占用较长的时间，一开启就占用内存，但是使用方便

懒汉式，使用的时候浪费时间，不占用内存，使用的时候会占用；

###25.02_多线程(Runtime类)

Runtime类是一个单例类

  Runtime r = Runtime.getRuntime();
  //r.exec("shutdown -s -t 300");		//300秒后关机
  r.exec("shutdown -a");				//取消关机

###25.03_多线程(Timer)(掌握)

Timer类:计时器

  	public class Demo5_Timer {
  		/**
  		 * @param args
  		 * 计时器
  		 * @throws InterruptedException 
  		 */
  		public static void main(String[] args) throws InterruptedException {
  			Timer t = new Timer();
  			t.schedule(new MyTimerTask(), new Date(114,9,15,10,54,20),3000);
  			
  			while(true) {
  				System.out.println(new Date());
  				Thread.sleep(1000);
  			}
  		}
  	}
  	class MyTimerTask extends TimerTask {
  		@Override
  		public void run() {
  			System.out.println("起床背英语单词");
  		}
  	}

###25.04_多线程(两个线程间的通信)(掌握)

1.什么时候需要通信
- 多个线程并发执行时, 在默认情况下CPU是随机切换线程的
- 如果我们希望他们有规律的执行, 就可以使用通信, 例如每个线程执行一次打印
2.怎么通信
- 如果希望线程等待, 就调用wait()
- 如果希望唤醒等待的线程, 就调用notify();
- 这两个方法必须在同步代码中执行, 并且使用同步锁对象来调用

###25.05_多线程(线程的五种状态)(掌握)

看图说话
新建,就绪,运行,阻塞,死亡
wait 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待
锁问题。 wait 在等待的时候是释放所对象
sleep 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
在sleep方式执行的时候是抱着锁（不释放锁）

###25.06_设计模式(简单工厂模式概述和使用)(了解)

A:简单工厂模式概述
- 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
B:优点
- 客户端不需要在负责对象的创建，从而明确了各个类的职责
C:缺点
- 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
D:案例演示
- 动物抽象类：public abstract Animal { public abstract void eat(); }
- 具体狗类：public class Dog extends Animal {}
- 具体猫类：public class Cat extends Animal {}
- 开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。

  public class AnimalFactory {
  	private AnimalFactory(){}
  
  	//public static Dog createDog() {return new Dog();}
  	//public static Cat createCat() {return new Cat();}
  
  	//改进
  	public static Animal createAnimal(String animalName) {
  		if(“dog”.equals(animalName)) {}
  		else if(“cat”.equals(animale)) {
  
  		}else {
  			return null;
  		}
  	}
  }

###25.07_设计模式(工厂方法模式的概述和使用)(了解)

A:工厂方法模式概述
- 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
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() {…}
          }

King && Coder

发布了29 篇原创文章 · 获赞 11 · 访问量 3962

私信关注

Java学习之线程(二)

猜你喜欢