JAVA知识点总结16-多线程

一：线程中的各种方法：

  1.public final void join():执行完这个线程，其他线程才能开始抢占

      MyThread m1=new MyThread();

MyThread m2=new MyThread();

mt1.start();    

        mt1.join();

mt2.start();

    2. public static void yield():暂停当前正在执行的线程对象， 并执行其他线程，但实际并无法实现

    3.线程死亡               public final void stop():直接杀死

    public void  interrupt():直接杀死，在死前，还可以有遗言，就是将run方法中的代码执行完

    

    4.线程组：它可以对一批线程进行管理，默认情况下所有线程属于主线程组

    A：创建线程：   MyThread mt1=new MyThread();

      获得线程组对象： ThreadGroup tg1=mt1.getThreadGroup();

          获得线程组名称： tg1.getName（）

  

    B：创建线程组对象： ThreadGroup tg=new ThreadGroup("刘德华"); 

                给线程分配线程组： Thread t3=new Thread(tg,new MyRunnable());

          获取线程组对象 ThreadGroup tg3=t3.getThreadGroup();

                                      给线程组命名

二：线程池：当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池          

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

  

1.创建线程池：

    ExecutorService pool = Executors.newFixedThreadPool(2); 数字是几个线程

2.一般流程：

        1.创建线程池对象

    ExecutorService pool = Executors.newFixedThreadPool(2);

2.创建了实现Runnable接口的对象                                      

    MyRunnable my1=new MyRunnable();

  3.提交任务，执行run()方法

pool.submit(my1);

4.关闭线程池

pool.shutdown();

3.实现Runnable接口实现线程池和实现Callable接口实现线程池的区别

Callable 会返回结果并抛出异常

三：定时器 Timer

 public abstract void run()放的是所要执行的任务代码

  1.创建Timer对象

    Timer t = new Timer();

  2.延迟多久执行任务，MyTimerTask是Timer的子类

    t.schedule(new MyTimerTask(t), 10000)；

  3.终止计时器

    t.cancel();

  4.延迟多久并隔多久执行一次

    t.schedule(new MyTimerTask2(), 5000, 1000);

 如何定时删除一个文件？

    Timer t = new Timer();

String time = "2017-05-20 16:31:00";
Date date = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time);
System.out.println(date);
//所用方法：schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务
t.schedule(new MyTimerTask(), date);
}


}


class MyTimerTask extends TimerTask{


@Override
public void run() {
//任务：删除D：//a.txt文件
File file = new File("D://a.txt");
file.delete();
}

}

    

   创建学生信息获取：将学生对象作为参数传入每个类的构造中，这样他们就使用 的都是同一个对象了

public class GetThread implements Runnable {
	private Student s;

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

	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				// 判断对象有没有数据
				if (!s.flag) {
					try {
						s.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println(s.name+"--"+s.age);
			   //当获取线程从学生对象中获取了数据之后，我们默认为他已经没有数据了
				//此时我们应该继续让设置线程继续给学生对象设置信息
				s.flag=false;
				s.notify();
				
			}
		}
	}

}
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){
			synchronized(s){
				//判断该对象此时有没有数据
				if(s.flag){
					try {
						s.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				if (x%2==0) {
					s.name = "刘嘉玲";
					s.age = 50;
				}else {
					s.name = "冠希";
					s.age = 35;
				}
				x++;//x=1
				s.flag=true;
				s.notify();
				//如果有等待线程就唤醒，如果没有，则没有任何操作
			}
		}
	}
}
public class Student {
  String name;
  int age;
  boolean flag;
  
}
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();
	}
	
}

本来应该输出一次刘嘉玲，在输出一次陈冠希，每人之输出一次且轮流输出；

但cup的一点点时间够程序执行很多次，所以我们要用等待唤醒机制实现礼让功能

public class GetThread implements Runnable {
	private Student s;

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

	}

	@Override
	public void run() {
		while (true) {
			synchronized (s) {
				// 判断对象有没有数据
				if (!s.flag) {
					try {
						s.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				System.out.println(s.name+"--"+s.age);
			   //当获取线程从学生对象中获取了数据之后，我们默认为他已经没有数据了
				//此时我们应该继续让设置线程继续给学生对象设置信息
				s.flag=false;
				s.notify();
				
			}
		}
	}

}
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){
			synchronized(s){
				//判断该对象此时有没有数据
				if(s.flag){
					try {
						s.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				if (x%2==0) {
					s.name = "刘嘉玲";
					s.age = 50;
				}else {
					s.name = "冠希";
					s.age = 35;
				}
				x++;//x=1
				s.flag=true;
				s.notify();
				//如果有等待线程就唤醒，如果没有，则没有任何操作
			}
		}
	}
}public class Student {
  String name;
  int age;
  boolean flag;
  
}
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();
	}
	
}

如果先获取，则发现里面没内容，则等待wait，然后进行设置，设置完后唤醒等待的线程

如果先设置，直接设置，然后唤醒获取线程，然后获取，在唤醒设置线程

   

   

      在进行优化，将学生类私有化，只提供一个公共的访问方法的口

   

public class GetTread implements Runnable {
	private Student s;

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

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

	}

}
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.setIofo("刘嘉玲", 45);
			}else{
				s.setIofo("梁朝伟", 50);
			}
			x++;
		}
		
	}
}
public class Student {
	private String name;
	private int age;
	private boolean flag;

	public synchronized void setIofo(String name, int age) {
		if (this.flag) {
			//判断设置线程是否有数据
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//没有值的话，在这里给对象设置数据
		this.name=name;//后面的name就是输入的数据，前面的name变量
		this.age=age; 
		
		//更改标记，唤醒获取线程获取数据
		this.flag=true;
		this.notify();
	}
	
	//提供公共的方法获取信息
	  public synchronized void getInfo(){
		  if(!this.flag){
			  //没有值，获取线程开始等待
			  try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		  }
		  //有数据，取数据
		  System.out.println(this.name+"--"+this.age);
		  
		  //取完数据之后，就没有数据了，唤醒设置线程
		  this.flag=false;
		  this.notify();
	  }
}
public class StudentDemo {
	public static void main(String[] args) {
               //创建学生对象
		Student s=new Student();
		//创建设置线程和获取线程
		SetThread st=new SetThread(s);
		GetTread gt=new GetTread(s);
		Thread t1=new Thread(st);
		Thread t2=new Thread(gt);
		
		//开启线程
		t1.start();
		t2.start();
	}
}