Java基础之多线程(二)

五、JDK5中Lock锁的使用


虽然我们可以理解同步代码块和同步方法的锁对象问题，
但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
为了更清晰的表达如何加锁和释放锁，
JDK5以后提供了一个新的锁对象Lock


Lock
void lock() ：获取锁
void unlock()：释放锁
ReentrantLock 是Lock的实现类.

public class SellTicket implements Runnable {

	// 定义票
	private int tickets = 100;

	// 定义锁对象
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while (true) {
			try {
				// 加锁
				lock.lock();
				if (tickets > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName()
							+ "正在出售第" + (tickets--) + "张票");
				}
			} finally {
				// 释放锁
				lock.unlock();
			}
		}
	}

}


public class SellTicketDemo {
	public static void main(String[] args) {
		// 创建资源对象
		SellTicket st = new SellTicket();

		// 创建三个窗口
		Thread t1 = new Thread(st, "窗口1");
		Thread t2 = new Thread(st, "窗口2");
		Thread t3 = new Thread(st, "窗口3");

		// 启动线程
		t1.start();
		t2.start();
		t3.start();
	}
}

六、 死锁

1.同步弊端
效率低
如果出现了同步嵌套，就容易产生死锁问题
2.死锁问题及其代码
是指两个或者两个以上的线程在执行的过程中，因争夺资源产生的一种互相等待现象

public class MyLock {
	// 创建两把锁对象
	public static final Object objA = new Object();
	public static final Object objB = new Object();
}

public class DieLock extends Thread {

	private boolean flag;

	public DieLock(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		if (flag) {
			synchronized (MyLock.objA) {
				System.out.println("if objA");
				synchronized (MyLock.objB) {
					System.out.println("if objB");
				}
			}
		} else {
			synchronized (MyLock.objB) {
				System.out.println("else objB");
				synchronized (MyLock.objA) {
					System.out.println("else objA");
				}
			}
		}
	}
}


public class DieLockDemo {
	public static void main(String[] args) {
		DieLock dl1 = new DieLock(true);
		DieLock dl2 = new DieLock(false);

		dl1.start();
		dl2.start();
	}
}

七、线程间的通信
针对同一个资源的操作有不同种类的线程
举例：卖票有进的，也有出的。


通过设置线程(生产者)和获取线程(消费者)针对同一个学生对象进行操作
虽然通过同步机制线程的安全问题解决了，但是一样存在着下面的问题
1.如果消费者先抢到CPU的执行权，就会消费数据，但是现在的数据是默认值，
没有意义，应该等着数据的产生，再消费
2.如果生产者先抢到CPU的执行权，就回去产生数据，但是，它产生完数据后，还继续拥有执行权，
它又继续产生数据，这是有问题的，应该等着消费者把数据消费掉，然后再生产。


正常思路：
A：生产者
先看是否有数据，有就等待，没有就生产，生产完之后通知消费者来消费数据
B:消费者
先看是否有数据，有就消费，没有就等待，通知生产者生产数据
为了处理这样的问题，Java就提供了一种机制，等待唤醒机制


生产者与消费者的示例

public class GetThread implements Runnable {
	private Student s;

	public GetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			s.get();
		}
	}
}



public class SetThread implements Runnable {

	private Student s;
	private int x = 0;

	public SetThread(Student s) {
		this.s = s;
	}

	@Override
	public void run() {
		while (true) {
			if (x % 2 == 0) {
				s.set("老大", 20);
			} else {
				s.set("小弟", 30);
			}
			x++;
		}
	}
}



public class Student {
	private String name;
	private int age;
	private boolean flag; // 默认情况是没有数据，如果是true，说明有数据

	public synchronized void set(String name, int age) {
		// 如果有数据，就等待
		if (this.flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		// 设置数据
		this.name = name;
		this.age = age;

		// 修改标记
		this.flag = true;
		this.notify();
	}

	public synchronized void get() {
		// 如果没有数据，就等待
		if (!this.flag) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		// 获取数据
		System.out.println(this.name + "---" + this.age);

		// 修改标记
		this.flag = false;
		this.notify();
	}
}



/*
  分析：
  		资源类：Student	
  		设置学生数据:SetThread(生产者)
  		获取学生数据：GetThread(消费者)
  		测试类:StudentDemo
  
 
  
  问题1：为了数据的效果好一些，我加入了循环和判断，给出不同的值,这个时候产生了新的问题
  		A:同一个数据出现多次
  		B:姓名和年龄不匹配
 原因：
 		A:同一个数据出现多次
  			CPU的一点点时间片的执行权，就足够你执行很多次。
  		B:姓名和年龄不匹配
  			线程运行的随机性
  线程安全问题：
  		A:是否是多线程环境		是
  		B:是否有共享数据		是
  		C:是否有多条语句操作共享数据	是
  解决方案：
  		加锁。
  		注意：
  			A:不同种类的线程都要加锁。
  			B:不同种类的线程加的锁必须是同一把。
  
  问题2:虽然数据安全了，但是呢，一次一大片不好看，我就想依次的一次一个输出。
  如何实现呢?
  		通过Java提供的等待唤醒机制解决。
 
  等待唤醒：
  		Object类中提供了三个方法：
  			wait():等待
  			notify():唤醒单个线程
  			notifyAll():唤醒所有线程
 		为什么这些方法不定义在Thread类中呢?
  			这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
  			所以，这些方法必须定义在Object类中。
 */
public class StudentDemo {
	public static void main(String[] args) {
		//创建资源
		Student s = new Student();
		
		//设置和获取的类
		SetThread st = new SetThread(s);
		GetThread gt = new GetThread(s);

		//线程类
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(gt);

		//启动线程
		t1.start();
		t2.start();
	}
}

八、线程组
Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类管理，Java允许程序直接对线程组进行控制。
默认情况下所有的线程都属于主线程组
public final ThreadGroup getThreadGroup()
我们也可以给线程设置分组
Thread(ThreadGroup group, Runnable target, String name)


如何修改线程所在的组呢?
创建一个线程组
创建其他线程的时候，把其他线程的组指定为我们自己新建线程组


九、线程池


1.程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。
而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。
线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。
在JDK5之前，我们必须手动实现自己的线程池，从JDK5开始，Java内置支持线程池。
JDK5新增了一个Executors工厂类来产生线程池，有如下几个方法
public static ExecutorService newCachedThreadPool()：创建一个具有缓存功能的线程池
public static ExecutorService newFixedThreadPool(int nThreads)：创建一个可重用的，具有固定线程数的线程池
public static ExecutorService newSingleThreadExecutor()：创建一个只有单线程的线程池，相当于上个方法的参数是1
这些方法的返回值是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
Future<?> submit(Runnable task)
<T> Future<T> submit(Callable<T> task)


2.如何实现线程池的代码呢?
  A:创建一个线程池对象，控制要创建几个线程对象。
  public static ExecutorService newFixedThreadPool(int nThreads)
  B:这种线程池的线程可以执行：
  可以执行Runnable对象或者Callable对象代表的线程
  做一个类实现Runnable接口。
  C:调用如下方法即可
  Future<?> submit(Runnable task)
  <T> Future<T> submit(Callable<T> task)
  D:可以结束线程池
 


 

案例演示

public class MyRunnable implements Runnable {

	@Override
	public void run() {
		for (int x = 0; x < 100; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
	}

}

public class ExecutorsDemo {
	public static void main(String[] args) {

		// 创建一个线程池对象，控制要创建几个线程对象。
		
		ExecutorService pool = Executors.newFixedThreadPool(2);

		// 可以执行Runnable对象或者Callable对象代表的线程
		pool.submit(new MyRunnable());
		pool.submit(new MyRunnable());

		//结束线程池
		pool.shutdown();
	}
}


	3.多线程的第三种实现方式

  	    A:创建一个线程池对象，控制要创建几个线程对象。
  			public static ExecutorService newFixedThreadPool(int nThreads)
  		B:这种线程池的线程可以执行：
  			可以执行Runnable对象或者Callable对象代表的线程
  			做一个类实现Runnable接口。
  		C:调用如下方法即可
  			
 			<T> Future<T> submit(Callable<T> task)
 		D:我就要结束，可以吗?
 			可以。
 
public class CallableDemo {

	public static void main(String[] args) {

		//创建线程池对象
		ExecutorService pool = Executors.newFixedThreadPool(2);
		
		//可以执行Runnable对象或者Callable对象代表的线程
		pool.submit(new MyCallable());
		pool.submit(new MyCallable());
		
		//结束
		pool.shutdown();
	}
}

		//Callable:是带泛型的接口。
		//这里指定的泛型其实是call()方法的返回值类型。
public class MyCallable implements Callable {

	@Override
	public Object call() throws Exception {
		for (int x = 0; x < 100; x++) {
			System.out.println(Thread.currentThread().getName() + ":" + x);
		}
		return null;
	}

}

//第三种方式实现求和案例

public class MyCallable implements Callable<Integer> {

	private int number;

	public MyCallable(int number) {
		this.number = number;
	}

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int x = 1; x <= number; x++) {
			sum += x;
		}
		return sum;
	}

}

public class CallableDemo {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建线程池对象
		ExecutorService pool = Executors.newFixedThreadPool(2);

		// 可以执行Runnable对象或者Callable对象代表的线程
		Future<Integer> f1 = pool.submit(new MyCallable(100));
		Future<Integer> f2 = pool.submit(new MyCallable(200));

		// V get()
		Integer i1 = f1.get();
		Integer i2 = f2.get();

		System.out.println(i1);
		System.out.println(i2);

		// 结束
		pool.shutdown();
	}
}

十、匿名内部类方式使用多线程



  匿名内部类的格式：
  new 类名或者接口名() {
  重写方法;
  };
  本质：是该类或者接口的子类对象。

new Thread(){


代码…
}.start();


new Thread(new Runnable(){
代码…
}).start();

public class ThreadDemo {
	public static void main(String[] args) {

		// 继承Thread类来实现多线程
		new Thread() {
			public void run() {
				for (int x = 0; x < 100; x++) {
					System.out.println(Thread.currentThread().getName() + ":"
							+ x);
				}
			}
		}.start();

		// 实现Runnable接口来实现多线程
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int x = 0; x < 100; x++) {
					System.out.println(Thread.currentThread().getName() + ":"
							+ x);
				}
			}
		}) {
		}.start();

		// 更有难度的
		//如果有两个run方法都实现了，那么运行的是Thread类的
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int x = 0; x < 100; x++) {
					System.out.println("hello" + ":" + x);
				}
			}
		}) {
			public void run() {
				for (int x = 0; x < 100; x++) {
					System.out.println("world" + ":" + x);
				}
			}
		}.start();
	}
}

十一、定时器类
定时器是一个应用十分广泛的线程工具，可用于调度多个定时任务以后台线程的方式执行。
在Java中，可以通过Timer和TimerTask类来实现定义调度的功能


依赖Timer和TimerTask这两个类：
  Timer:定时类
  public Timer()
  public void schedule(TimerTask task,long delay)：安排在指定延迟后执行指定的任务。
  public void schedule(TimerTask task,long delay,long period)：安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
  public void cancel()：终止此计时器，丢弃所有当前已安排的任务。
  TimerTask:任务类
public abstract void run()：此计时器任务要执行的操作。
public boolean cancel():取消此计时器任务。


开发中
Quartz是一个完全由java编写的开源调度框架。

public class TimerDemo2 {
	public static void main(String[] args) {
		// 创建定时器对象
		Timer t = new Timer();
		// 3秒后执行爆炸任务第一次，如果不成功，每隔2秒再继续炸
		t.schedule(new MyTask(), 3000, 2000);
	}
}

// 做一个任务
class MyTask extends TimerTask {
	@Override
	public void run() {
		System.out.println("beng,爆炸了");
	}
}

//需求：在指定的时间删除我们的指定目录
class DeleteFolder extends TimerTask {

	@Override
	public void run() {
		File srcFolder = new File("demo");
		deleteFolder(srcFolder);
	}

	// 递归删除目录
	public void deleteFolder(File srcFolder) {
		File[] fileArray = srcFolder.listFiles();
		if (fileArray != null) {
			for (File file : fileArray) {
				if (file.isDirectory()) {
					deleteFolder(file);
				} else {
					System.out.println(file.getName() + ":" + file.delete());
				}
			}
			System.out.println(srcFolder.getName() + ":" + srcFolder.delete());
		}
	}
}

public class TimerTest {
	public static void main(String[] args) throws ParseException {
		Timer t = new Timer();

		String s = "2016-3-3 15:00:00";
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = sdf.parse(s);

		t.schedule(new DeleteFolder(), d);
	}
}

十二、设计模式之单例设计模式
单例设计思想
保证类在内存中只有一个对象
如何实现类在内存中只有一个对象呢?
构造私有
本身提供一个对象
通过公共的方法让外界访问


    单例模式：
  饿汉式：类一加载就创建对象
  懒汉式：用的时候，才去创建对象
  
面试题：单例模式的思想是什么?请写一个代码体现。
  
  开发：饿汉式(是不会出问题的单例模式)
  面试：懒汉式(可能会出问题的单例模式)
  A:懒加载(延迟加载)
  B:线程安全问题
  a:是否多线程环境 是
  b:是否有共享数据 是
  c:是否有多条语句操作共享数据 是
解决方式：同步函数

	//饿汉式
public class Student {

	// 构造私有
	private Student() {
	}

	// 自己造一个
	// 静态方法只能访问静态成员变量，加静态
	// 为了不让外界直接访问修改这个值，加private
	private static Student s = new Student();

	// 提供公共的访问方式
	// 为了保证外界能够直接使用该方法，加静态
	public static Student getStudent() {
		return s;
	}
}

public class StudentDemo {
	public static void main(String[] args) {
		

		Student s1 = Student.getStudent();
		Student s2 = Student.getStudent();
		System.out.println(s1 == s2);

		System.out.println(s1); 
		System.out.println(s2);
	}
}

		//懒汉式

public class Teacher {

	private Teacher() {
	}

	private static Teacher t = null;

	public synchronized static Teacher getTeacher() {
		
		if (t == null) {
			
			t = new Teacher();
		}
		return t;
	}
}


public class TeacherDemo {
	public static void main(String[] args) {

		Teacher t1 = Teacher.getTeacher();
		Teacher t2 = Teacher.getTeacher();
		System.out.println(t1 == t2);
		System.out.println(t1); 
		System.out.println(t2);
	}
}

	在Java中提供了一个单例类就是Runtime类
	Runtime ：每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
	exec(String command)：这个方法可以调用dos命令
public class RuntimeDemo {
	public static void main(String[] args) throws IOException {
		Runtime r = Runtime.getRuntime();
		r.exec("winmine");
	
	}
}

十三、多线程中常见的面试题


1:多线程有几种实现方案，分别是哪几种?
两种。

继承Thread类
实现Runnable接口

扩展一种：实现Callable接口。这个得和线程池结合。


2:同步有几种方式，分别是什么?
两种。

同步代码块
同步方法


3:启动一个线程是run()还是start()?它们的区别?
start();

run():封装了被线程执行的代码,直接调用仅仅是普通方法的调用
start():启动线程，并由JVM自动调用run()方法


4:sleep()和wait()方法的区别
sleep():必须指时间;不释放锁。
wait():可以不指定时间，也可以指定时间;释放锁。


5:为什么wait(),notify(),notifyAll()等方法都定义在Object类中
因为这些方法的调用是依赖于锁对象的，而同步代码块的锁对象是任意锁。
而Object代码任意的对象，所以，定义在这里面。


6:线程的生命周期图
新建 -- 就绪 -- 运行 -- 死亡
新建 -- 就绪 -- 运行 -- 阻塞 -- 就绪 -- 运行 -- 死亡