(48)Java学习笔记——多线程 / 线程间通信 / 线程组 / 线程池 /

加锁注意：

A / 不同种类的县城都要加锁

B / 不同种类的线程家的锁必须是同一把。

等待唤醒机制：

void wait()

void notify()

void notifyAll()

这些方法的调用必须通过锁对象调用。

范例：**生产者和消费者问题

package cn.itcast_02;

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();
	}
}

package cn.itcast_02;

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("生产包子", 1);
			}
			else {
				s.set("吃掉————包子", 1);
			}
			x++;
		}
		
	}
}

package cn.itcast_02;

public class GetThread implements Runnable {
	private Student s;
	
	public GetThread(Student s){
		this.s = s;
		
	}
	@Override
	public void run() {
		while (true){
			s.get();
		}
		
	}

}

package cn.itcast_02;
/*
 * 测试类
 */
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();
	}
}

——————————————————————————————

线程组

ThreadGroup

对一批线程进行分类管理。

————————————————————————————————

线程池

Executors 工厂类

线程池里的每一个线程代码结束后，并不会死亡，而是回到线程池中成为空闲状态，等待下一个对象调用。

步骤：

A / 创建一个线程池对象，控制要创建几个线程对象

public static ExecutorService newFixedThreadPool ( int  nThreads)

B / 这种线程池的线程可以执行Runnable 对象或者Collable 对象代表的线程。

      做一个类是想Runnable接口

C / 调用如下方法即可

Future<?> submit (Runnable task)

<T> Future <T> submit (Callable<T> task)

D / 把线程池结束

void shutdown();

范例：

package cn.itcast_03;

public class MyRunnable implements Runnable {

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

}

package cn.itcast_03;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * A / 创建一个线程池对象，控制要创建几个线程对象
public static ExecutorsService newFixedThreadPool ( int  nThreads)
B / 这种线程池的线程可以执行Runnable 对象或者Collable 对象代表的线程。
      做一个类是想Runnable接口
C / 调用如下方法即可
Future<?> submit (Runnable task)
<T> Future <T> submit (Callable<T> task)
 */
public class ExecutorsDemo {
	public static void main(String[] args) {
		//创建一个线程池对象，控制要创建几个线程对象
		//public static ExecutorService newFixedThreadPool ( int  nThreads)
		ExecutorService pool = Executors.newFixedThreadPool(2);
		
		//这种线程池的线程可以执行Runnable 对象或者Collable 对象代表的线程。
		pool.submit(new MyRunnable());
		pool.submit(new MyRunnable());
		
		//结束线程池
		pool.shutdown();
	}
}