JavaSE之线程Thread

package com.shuhuadream.thread;
/**
 * 
 * 进程：正在执行的程序称为一个进程
 * 
 * 线程：线程在一个进程中负责了代码的执行，就是进程中一个执行路径
 * 
 * 多线程：线程负责了代码的执行，我们之前没有学过线程，为啥代码可以执行?
 * 			运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有的代码
 * 
 * 一个java应用程序至少有几个线程？
 * 	至少有两个线程，一个是主方法负责main方法代码的执行，一个是垃圾回收器线程负责垃圾回收
 * 
 * 多线程的好处：
 * 	1.解决了一个进程能同时执行多个任务的问题
 * 	2.提高了资源的利用率
 * 
 * 多线程的弊端：
 * 	1.增加了cpu的负担
 * 	2.降低了一个进程中线程的执行概率
 * 	3.引发了线程安全问题
 * 	4.出现了死锁想象
 * 
 * 如何创建多线程？
 * 方式：
 * 一、1.自定义一个类继承Thread类
 * 	   2.重写Thread类的run方法
 * 		重写的目的：
 * 			每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码，
 * 			自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码
 * 	   3.创建Thread的子类对象，并且调用start方法开启线程。
 * 			一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，
 * 			直接调用run()方法就相当于调用了一个普通的方法而已，并没有开启新的线程
 * 
 * 
 * 
 * 线程的生命周期：
 * 
 *
 */
public class Demo01 extends Thread{
	
	//把自定义线程的任务代码写在run方法中
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("自定义线程："+i);
		}
	}

	public static void main(String[] args){
		Demo01 d = new Demo01();
		d.start();
		for(int i=0;i<100;i++){
			System.out.println("主线程:"+i);
		}
	}
}

package com.shuhuadream.thread;
/*
 进程 ：  正在执行的程序称作为一个进程。  进程负责了内存空间的划分。
 
问题： windows号称是多任务的操作系统,那么windows是同时运行多个应用程序吗？
	
	从宏观的角度： windows确实是在同时运行多个应用程序。
	
	从微观角度： cpu是做了一个快速切换执行的动作，由于速度态度，所以我感觉不到在切换 而已。

线程： 线程在一个进程 中负责了代码的执行，就是进程中一个执行路径，

多线程： 在一个进程中有多个线程同时在执行不同的任务。

疑问 ：线程负责了代码 的执行，我们之前没有学过线程，为什么代码可以执行呢？
	运行任何一个java程序，jvm在运行的时候都会创建一个main线程执行main方法中所有代码。

一个java应用程序至少有几个线程？
	至少有两个线程， 一个是主线程负责main方法代码的执行，一个是垃圾回收器线程,负责了回收垃圾。

多线程的好处：
	1. 解决了一个进程能同时执行多个任务的问题。
	2. 提高了资源的利用率。

多线程 的弊端：
	1. 增加cpu的负担。
	2. 降低了一个进程中线程的执行概率。
	3. 引发了线程安全 问题。
	4. 出现了死锁现象。
	
如何创建多线程：
	
	创建线程的方式：
	
		方式一：
			1. 自定义一个类继承Thread类。
			2. 重写Thread类的run方法 , 把自定义线程的任务代码写在run方法中
				疑问： 重写run方法的目的是什么？  
			   每个线程都有自己的任务代码，jvm创建的主线程的任务代码就是main方法中的所有代码, 自定义线程的任务代码就写在run方法中，自定义线程负责了run方法中代码。	
			3. 创建Thread的子类对象，并且调用start方法开启线程。
				
			注意：	一个线程一旦开启，那么线程就会执行run方法中的代码，run方法千万不能直接调用，直接调用run方法就相当调用了一个普通的方法而已
				并没有开启新的线程。
			
 */
public class Demo02 extends Thread {
	
	@Override  //把自定义线程的任务代码写在run方法中。
	public void run() {
		for(int i  = 0 ; i < 100 ; i++){
			System.out.println("自定义线程："+i);
		}
	}
	
	
	public static void main(String[] args) {
		//创建了自定义的线程对象。
		Demo02 d = new Demo02();
		//调用start方法启动线程
		d.start();
		
		for(int i  = 0 ; i < 100 ; i++){
			System.out.println("main线程："+i);
		}
	}

	
	
}

/*
 需求： 模拟3个窗口同时在售50张 票 。
 
问题1 ：为什么50张票被卖出了150次？

出现 的原因： 因为num是非静态的，非静态的成员变量数据是在每个对象中都会维护一份数据的,三个线程对象就会有三份。

解决方案：把num票数共享出来给三个线程对象使用。使用static修饰。

问题2： 出现了线程安全问题 ?

线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。
	
	java线程同步机制的方式：
	
		方式一：同步代码块
			
			同步代码块的格式：
				
				synchronized(锁对象){
					需要被同步的代码...
				}

同步代码块要注意事项：
		1. 任意的一个对象都可以做为锁对象。
		2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
		3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
		4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。
		

需求： 一个银行账户5000块，两夫妻一个拿着 存折，一个拿着卡，开始取钱比赛，每次只能取一千块，要求不准出现线程安全问题。
		
		
		
		方式二：同步函数

出现线程安全问题的根本原因：
	1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
	2. 有多个语句操作了共享资源。
	

 
 */

class SaleTicket extends Thread{
		
	
	 static int num = 50;//票数  非静态的成员变量,非静态的成员变量数据是在每个对象中都会维护一份数据的。
	 
     static	Object o = new Object();
	
	 public SaleTicket(String name) {
		super(name);
	}
	
	@Override
	public void run() {
		while(true){
			//同步代码块
			synchronized ("锁") {				
				if(num>0){
					System.out.println(Thread.currentThread().getName()+"售出了第"+num+"号票");
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					num--;
				}else{
					System.out.println("售罄了..");
					break;
				}
			}
			
		}
	}	
	
	
} 


public class Demo4 {
	
	public static void main(String[] args) {
		//创建三个线程对象，模拟三个窗口
		SaleTicket thread1 = new SaleTicket("窗口1");
		SaleTicket thread2 = new SaleTicket("窗口2");
		SaleTicket thread3 = new SaleTicket("窗口3");
		//开启线程售票
		thread1.start();
		thread2.start();
		thread3.start();
		
	}
	
}

package com.shuhuadream.thread;

class Test03 extends Thread{
	//把自定义线程的任务代码写在run方法中
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("视频聊天");
		}
	}	
}


class Test02 extends Thread{
	//把自定义线程的任务代码写在run方法中
	public void run() {
		for(int i=0;i<100;i++){
			System.out.println("打字聊天");
		}
	}	
}

public class Test01{
	public static void main(String[] args) {
		Test02 t2 = new Test02();
		Test03 t3 = new Test03();
		t2.start();
		t3.start();
	}
}

		方式二：同步函数  同步函数就是使用synchronized修饰一个函数
		同步函数要注意的事项：
			1.如果是一个非静态的同步函数的锁，对象是this对象，如果是静态的同步函数的锁 对象时当前函数
				所属的类的字节码文件（class对象）
			2.同步函数的锁对象是固定的，不能由你来指定的
			
		推荐使用同步代码块
		原因：1.同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象时固定的，不能由我们来指定
		2.同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数的所有代码都被同步了。
 */

package com.shuhuadream.thread;
/*
 * java中同步机制解决了线程安全问题，但是同时也引发死锁现象
 * 
 * 死锁现象：
 * 
 * 死锁现象出现的根本原因：
 * 	1.存在两个或者两个以上线程
 * 	2.存在两个或者两个以上共享资源
 * 
 * 死锁现象的解决方案：没有方案，只能尽量避免发生而已
 */
class DeadLock extends Thread{
	
	public DeadLock(String name){
		super(name);
	}
	
	public void run(){
		if("张三".equals(Thread.currentThread().getName())){
			synchronized ("遥控器") {
				System.out.println("张三拿到了遥控器，准备去拿电池！！");
				synchronized ("电池") {
					System.out.println("张三拿到了遥控器和电池，开着空调爽歪歪的吹着。。。");
				}
			}
		}else if("狗娃".equals(Thread.currentThread().getName())){
			synchronized ("电池") {
				System.out.println("狗娃拿到了电池，准备去拿遥控器！！");
				synchronized ("遥控器") {
					System.out.println("狗娃拿到了遥控器和电池，开着空调爽歪歪的吹着。。。");
				}
			}
		}
	}
}
public class Demo02 {
	public static void main(String[] args) {
		DeadLock thread1 = new DeadLock("张三");
		DeadLock thread2 = new DeadLock("狗娃");
		//开启线程
		thread1.start();
		thread2.start();
	}
}

package com.shuhuadream.thread;
/*
 * 自定义线程创建方式：
 * 方式一：1.自定义一个类继承Thread类
 * 		2.重写Thread类的run方法，把自定义线程的任务代码写在run方法上
 * 		3.创建Thread的子对象，并且调用start方法启动一个线程
 * 
 * 	注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码，
 * 		如果直接调用run方法，就相当于调用了一个普通的方法而已。
 * 
 * 方式二：1.自定义一个类实现Runnable接口
 * 		2.实现Runnerable接口的run方法，把自定义线程的任务定义在run方法上
 * 		3.创建Runnerable实现类的对象.
 * 		4.创建Thread类的对象，并且把Runnerable实现类的对象作为实参传递
 * 		5.调用Thread对象的start方法开启一个线程
 * 
 * 问题一：请问Runnerable实现类的对象时线程对象吗？
 * 	Runnerable实现类的对象并不是一个线程对象，只不是实现了Runnerable接口的对象而已
 * 只有是Thread或者是Thread的子类才是线程对象
 * 
 * 问题二：为什么要把Runnerable实现类的对象作为实参传递给Thread对象呢？作用是什么？
 * 作用就是把Runnerable实现类的对象的run方法作为了线程的任务代码去执行了。
 * 
 */
public  class Demo03 implements Runnable{
	public void run(){
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
	
	public static void main(String[] args) {
		//创建Runnable实现类的对象
		Demo03 d = new Demo03();
		//创建Thread类的对象，把Runnable实现类对象作为实参传递
		Thread thread = new Thread(d,"狗娃");//Thread类使用Target变量记录了d对象
		//调用thread对象的方法开启线程
		thread.start();
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
}

class SaleTicket implements Runnable{
	
	int  num = 50; // 票数
	
	@Override
	public void run() {
		while(true){
			synchronized ("锁") {
				if(num>0){
					System.out.println(Thread.currentThread().getName()+"售出了第"+ num+"号票");
					num--;
				}else{
					System.out.println("售罄了..");
					break;
				}	
			}
		}		
	}
}


public class Demo4 {
	
	public static void main(String[] args) {
		//创建了一个Runnable实现类的对象
		SaleTicket saleTicket = new SaleTicket();
		//创建三个线程对象模拟三个窗口
		Thread thread1 = new Thread(saleTicket,"窗口1");
		Thread thread2 = new Thread(saleTicket,"窗口2");
		Thread thread3 = new Thread(saleTicket,"窗口3");
		//开启线程售票
		thread1.start();
		thread2.start();
		thread3.start();
		
		
	}

}

package com.shuhuadream.thread;
/**
 * 进程：进程就是正在运行的应用程序，进程负责了内存空间划分
 * 
 * 线程：一个进程中的代码是由线程去执行的，线程也就是进程中一个执行路径
 * 
 * 多线程：一个进程中有多个线程可以同时执行任务
 * 
 * 多线程的好处：
 * 	1.解决了一个进程中可以同时执行多个任务的问题
 * 	2.提高了资源利用率
 * 
 * 多线程的弊端：
 * 1.增加了cpu的负担
 * 2.降低了一个进程中线程的执行概率
 * 3.出现了线程安全问题
 * 4.会引发死锁现象
 * 
 * 自定义线程的是实现方式：
 * 方式一：1.自定义一个类继承Thread类
 * 		2.重写Thread类的run方法，把自定义线程的任务代码写在run方法上
 * 		3.创建Thread的子对象，并且调用start方法启动一个线程
 * 
 * 	注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码，
 * 		如果直接调用run方法，就相当于调用了一个普通的方法而已。
 * 
 * 出现线程安全问题的根本原因：
	1. 存在两个或者两个以上 的线程对象,而且线程之间共享着一个资源。
	2. 有多个语句操作了共享资源。
	
	线程 安全问题的解决方案：sun提供了线程同步机制让我们解决这类问题的。
	
	java线程同步机制的方式：
	
		方式一：同步代码块
			
			同步代码块的格式：
				
				synchronized(锁对象){
					需要被同步的代码...
				}

		同步代码块要注意事项：
			1. 任意的一个对象都可以做为锁对象。
			2. 在同步代码块中调用了sleep方法并不是释放锁对象的。
			3. 只有真正存在线程安全问题的时候才使用同步代码块，否则会降低效率的。
			4. 多线程操作的锁 对象必须 是唯一共享 的。否则无效。
		
		
		
		方式二：同步函数  同步函数就是使用synchronized修饰一个函数
		同步函数要注意的事项：
			1.如果是一个非静态的同步函数的锁，对象是this对象，如果是静态的同步函数的锁 对象时当前函数
				所属的类的字节码文件（class对象）
			2.同步函数的锁对象是固定的，不能由你来指定的
			
		推荐使用同步代码块
		原因：1.同步代码块的锁对象可以由我们随意指定，方便控制。同步函数的锁对象时固定的，不能由我们来指定
		2.同步代码块可以很方便控制需要被同步代码的范围，同步函数必须是整个函数的所有代码都被同步了。
 */
public class Demo01 {
	
}

class MoneyThread extends Thread{
	static int money = 5000;
	static Object o = new Object();
	
	public MoneyThread(String name){
		super(name);
	}
	
	public synchronized void run(){
		while(true){
			synchronized(o){
				if(money>0){
					System.out.println(Thread.currentThread().getName()+"取出1000元");
					money-=1000;
				}else{
					System.out.println("余额不足，无法进行取款");
					break;
				}
			}
		}
	}
}

package com.shuhuadream.thread;
/*
 * java中同步机制解决了线程安全问题，但是同时也引发死锁现象
 * 
 * 死锁现象：
 * 
 * 死锁现象出现的根本原因：
 * 	1.存在两个或者两个以上线程
 * 	2.存在两个或者两个以上共享资源
 * 
 * 死锁现象的解决方案：没有方案，只能尽量避免发生而已
 */
class DeadLock extends Thread{
	
	public DeadLock(String name){
		super(name);
	}
	
	public void run(){
		if("张三".equals(Thread.currentThread().getName())){
			synchronized ("遥控器") {
				System.out.println("张三拿到了遥控器，准备去拿电池！！");
				synchronized ("电池") {
					System.out.println("张三拿到了遥控器和电池，开着空调爽歪歪的吹着。。。");
				}
			}
		}else if("狗娃".equals(Thread.currentThread().getName())){
			synchronized ("电池") {
				System.out.println("狗娃拿到了电池，准备去拿遥控器！！");
				synchronized ("遥控器") {
					System.out.println("狗娃拿到了遥控器和电池，开着空调爽歪歪的吹着。。。");
				}
			}
		}
	}
}
public class Demo02 {
	public static void main(String[] args) {
		DeadLock thread1 = new DeadLock("张三");
		DeadLock thread2 = new DeadLock("狗娃");
		//开启线程
		thread1.start();
		thread2.start();
	}
}

package com.shuhuadream.thread;
/*
 * 自定义线程创建方式：
 * 方式一：1.自定义一个类继承Thread类
 * 		2.重写Thread类的run方法，把自定义线程的任务代码写在run方法上
 * 		3.创建Thread的子对象，并且调用start方法启动一个线程
 * 
 * 	注意：千万不要直接调用run方法，调用start方法的时候线程就会开启，线程一旦开启就会执行run方法中代码，
 * 		如果直接调用run方法，就相当于调用了一个普通的方法而已。
 * 
 * 方式二：1.自定义一个类实现Runnable接口
 * 		2.实现Runnerable接口的run方法，把自定义线程的任务定义在run方法上
 * 		3.创建Runnerable实现类的对象.
 * 		4.创建Thread类的对象，并且把Runnerable实现类的对象作为实参传递
 * 		5.调用Thread对象的start方法开启一个线程
 * 
 * 问题一：请问Runnerable实现类的对象时线程对象吗？
 * 	Runnerable实现类的对象并不是一个线程对象，只不是实现了Runnerable接口的对象而已
 * 只有是Thread或者是Thread的子类才是线程对象
 * 
 * 问题二：为什么要把Runnerable实现类的对象作为实参传递给Thread对象呢？作用是什么？
 * 作用就是把Runnerable实现类的对象的run方法作为了线程的任务代码去执行了。
 * 
 * 推荐使用：第二种。实现Runable接口的。
 * 原因：因为java是单继承，多实现的
 * 
 */
public  class Demo03 implements Runnable{
	public void run(){
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
	
	public static void main(String[] args) {
		//创建Runnable实现类的对象
		Demo03 d = new Demo03();
		//创建Thread类的对象，把Runnable实现类对象作为实参传递
		Thread thread = new Thread(d,"狗娃");//Thread类使用Target变量记录了d对象
		//调用thread对象的方法开启线程
		thread.start();
		for(int i=0;i<100;i++){
			System.out.println(Thread.currentThread().getName()+"："+i);
		}
	}
}

package com.shuhuadream.thread;
/*
 * 线程通讯：一个线程完成自己的任务时，要通知另外一个线程去完成另外一个任务
 * 生产者和消费者
 * 
 * wait(): 等待-----如果线程执行了wait方法，那么线程会进入等待的状态，等待状态下的线程必须要被其他线程调用notify方法才能唤醒
 * notify(): 唤醒-----唤醒等待的线程

notifyAll():唤醒线程池中所有等待的线程
 * 
 * wait与notify方法要注意的事项：
 * 	1.wait方法与notify方法时属于Object对象的
 *  2.wait方法与notify方法必须要在同步代码块或者是同步函数中才能使用
 *  3.wait方法与notify方法必须要由锁对象调用
 */

//产品类

class Product{
	String name;
	double price;
	boolean flag = false;//产品是否生产完毕的标识，默认是没有生产完毕
	
}

//生产者
class Producer extends Thread{
	Product p;
	
	public Producer(Product p){
		this.p = p;
	}
	
	public Producer(String name){
		super(name);
	}
	
	public void run(){
		int i = 0;
		while(true){
			synchronized (p) {
				if(p.flag==false){
				if(i%2==0){
					p.name = "苹果";
					try {
						Thread.sleep(10);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					p.price = 6.5;
				}else{
					p.name = "香蕉";
					p.price = 2.0;
				}
				System.out.println("生产者生产出了："+p.name+"  价格是："+p.price);
				p.flag=true;
				i++;
				p.notify();//唤醒消费者去消费
			}else{
				//已经生产完毕，等待消费者消费
				try {
					p.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}	
			}
		}
	}
}
//消费者
class Customer extends Thread{
	Product p;
	
	public Customer(Product p){
		this.p = p;
	}
	
	public void run(){
		while(true){
			synchronized (p) {
				if(p.flag==true){
					System.out.println("消费者消费了"+p.name+" 价格："+p.price);
					p.flag = false;
					p.notify();//唤醒生产者去生产
				}else{
					//产品还没生产，等待消费者生产
					try {
						p.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}			
		}
	}
}
public class Demo04 {
	public static void main(String[] args) {
		Product p = new Product();//产品
		//创建生产对象
		Producer producer = new Producer(p);
		//创建消费者
		Customer customer = new Customer(p);
		
		//调用start方法开启线程
		producer.start();
		customer.start();
	}
}

package com.shuhuadream.thread;
/*
 * 线程的停止：
 * 	1.停止一个线程我们一般都会通过一个变量去控制的。
 * 2.如果需要停止一个处于等待状态下的线程，我们需要通过变量配合notify方法或者interrupt()方法来使用
 */
public class Demo05 extends Thread{
	boolean flag = true;
	public Demo05(String name){
		super(name);
	}
	
	public synchronized void run(){
		int i = 0;
		while(flag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				System.out.println("接收到了异常了。。。");
			}
			System.out.println(Thread.currentThread().getName()+":"+i);
			i++;
		}
	}
	
	public static void main(String[] args) {
		Demo05 d = new Demo05("狗娃");
		d.start();
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
			//当主线程i为80时候
			if(i==80){
				d.flag = false;
				d.interrupt();//把线程的等待状态强制清除，被清除状态的线程会接收到一个InterruptedException
//				synchronized (d) {
//					d.notify();
//				}
			}
		}
	}
}

package com.shuhuadream.thread;
/*
 * 守护线程（后台线程）:如果在一个进程中只剩下守护线程，那么守护线程也会死亡
 */
public class Demo06 extends Thread{
	public Demo06(String name) {
		super(name);
	}
	
	@Override
	public void run() {
		for(int i=1;i<=100;i++){
			System.out.println("更新包下载到"+i+"%");
			if(i==100){
				System.out.println("更新包下载完毕，准备安装。。。");
			}
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		Demo06 d = new Demo06("后台线程");
		
		d.setDaemon(true);//setDaemon() 设置线程是否为守护线程，true为守护线程，false为非守护线程
		System.out.println("是守护线程吗？"+d.isDaemon());//判断线程是否为守护线程
		d.start();
		for(int i=1;i<=100;i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

package com.shuhuadream.thread;
/*
 * join方法：
 */

class Mom extends Thread{
	@Override
	public void run() {
		System.out.println("妈妈洗菜");
		System.out.println("妈妈切菜");
		System.out.println("妈妈准备炒菜，发现没酱油。。。");
		//叫儿子打酱油
		Son s = new Son();
		s.start();
		try {
			s.join();//加入 一个线程如果执行join语句，那么就有新的线程加入，执行该语句的线程必须要让步给
			//新加入的线程先完成任务，然后才能继续执行
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("妈妈继续炒菜");
		System.out.println("妈妈全家一起吃饭");
		
	}
}

class Son extends Thread{
	@Override
	public void run() {
		System.out.println("儿子下楼");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("儿子一直往前走。。");
		System.out.println("儿子打到酱油了");
		System.out.println("儿子上楼，把酱油给老妈");	
	}
}
public class Demo07 {
	public static void main(String[] args) {
		Mom m = new Mom();
		m.start();
	}
}