JAVA基础——多线程（一）开启线程的两种方式，休眠，守护，加入，礼让线程介绍，线程同步问题，线程安全问题，线程死锁问题

一、多线程的引入

什么是线程
线程是程序执行的一条路径, 一个进程中可以包含多条线程
多线程并发执行可以提高程序的效率, 可以同时完成多项工作
多线程的应用场景
红蜘蛛同时共享屏幕给多个电脑
迅雷开启多条线程一起下载
QQ同时和多个人一起视频
服务器同时处理多个客户端请求

二、多线程并行和并发的区别

并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。
如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

三、 Java程序运行原理

Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。JVM的启动至少启动了垃圾回收线程和主线程，所以是多线程的。

四、多线程程序实现（开启线程）

方式一：继承Thread

定义类继承Thread
重写run方法
把新线程要做的事写在run方法中
创建线程对象
开启新线程, 内部会自动执行run方法（start()方法）

public static void main(String[] args) {
    
    
		MyThread myThread =new MyThread();	
//创建Thread类的子类对象
		//myThread.run();
		myThread.start();
		for (int i = 0; i < 1000; i++) {
    
    
			System.out.println("yyy");
		}
	}
}
class MyThread extends Thread{
    
    			//1，继承Thread
	public void run() {
    
    					//2.重写run方法	
		for (int i = 0; i < 1000; i++) {
    
    //3.将要执行的代码写在run方法中
			System.out.println("xx");
		}
	}

效果如下：（此时 x和 y 会不定时的相互输出）
在这里插入图片描述
方式二：实现Runnable
定义类实现Runnable接口

实现run方法
把新线程要做的事写在run方法中
创建自定义的Runnable的子类对象
创建Thread对象, 传入Runnable
调用start()开启新线程, 内部会自动调用Runnable的run()方法

public static void main(String[] args) {
    
    
		MyRunable myRunable =new MyRunable();	
//4.创建Runnable的子类对象
Thread thread =new Thread(myRunable);	
//5.将其当作参数传递给Thread的构造函数
		thread.start();							//开启线程
		for (int i = 0; i < 1000; i++) {
    
    	
//3.将要执行的代码卸载run方法中
			System.out.println("b");
		}
	}

}

class MyRunable implements Runnable{
    
    		
//1.定义一个类实现Runnable
	@Override
	public void run() {
    
    			//2.重写run方法
		for (int i = 0; i < 1000; i++) {
    
    
//3.将要执行的代码卸载run方法中
			System.out.println("a");
		}
		
	}

效果如下：
在这里插入图片描述

五、实现Runnable的原理

看Thread类的构造函数,传递了Runnable接口的引用
通过init()方法找到传递的target给成员变量的target赋值
查看run方法,发现run方法中有判断,如果target不为null就会调用Runnable接口子类对象的run方法

六、两种方式的区别

角度一：（查看源码的区别）

方式一：继承Thread ：

由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法

方式二：实现Runnable ：

构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法

角度二：

方式一：继承Thread

好处是:可以直接使用Thread类中的方法,代码简单
弊端是:如果已经有了父类,就不能用这种方法

方式二：实现Runnable接口

好处是:即使自己定义的线程类有了父类也没关系，因为有了父类也可以实现接口,而且接口是可以多实现的
弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂。

七、匿名内部类实现线程的两种方式（开启线程另一种方式）

方式一：继承Thread类

new Thread() {
    
    			//1.继承Thread类
public void run() {
    
    	    //2.重写run方法
	for (int i = 0; i < 1000; i++) {
    
    
//3.将要执行的代码写在run方法中
		System.out.println("a");
		}
	}
}.start();				//4.开启线程

方式二：实现Runnable接口

new Thread(new Runnable() {
    
    			//1.将Runable的子类对象传递给Thread的构造方法
public void run() {
    
    					//2.重写run方法
	for (int i = 0; i < 1000; i++) {
    
    
//3.将要执行的代码写在run方法中
					System.out.println("b");
				}
			}
}).start();						//4.开启线程

八、获取名字和设置名字

线程也是可以获得名字和设置名字的
1.获取名字

通过getName()方法获取线程对象的名字

2.设置名字

通过构造函数可以传入String类型的名字

方式一：设置名字可以通过构造方法去实现

new Thread("线程a") {
    
    		//构造方法实现设置线程名字
			public void run() {
    
    
				System.out.println(this.getName()+"a");
			}
		}.start();
new Thread("线程b") {
    
    		//构造方法实现设置线程名字
			public void run() {
    
    
				System.out.println(this.getName()+"b");
			}
		}.start();
	}

效果如下：
在这里插入图片描述
方式二：

new Thread() {
    
    
		public void run() {
    
    
			this.setName("线程c");//设置线程名
			System.out.println(this.getName()+"     a");
		}
}.start();	
new Thread() {
    
    
		public void run() {
    
    
			this.setName("线程d");//设置线程名
			System.out.println(this.getName()+"    b");
		}
}.start();

效果如下：
在这里插入图片描述
方式三：（整个花括号代表子类对象）

Thread t1= new Thread() {
    
    
			public void run() {
    
    
				this.setName("线程c");
				System.out.println(this.getName()+"     a");
			}
		};
		
Thread t2= new Thread() {
    
    
			public void run() {
    
    
				this.setName("线程d");
				System.out.println(this.getName()+"    b");
			}
		};
		t1.setName("线程c");
		t2.setName("线程d");

九、获取当前线程的对象

Thread.currentThread获取当前正在执行的线程

new Thread() {
    
    
			public void run() {
    
    
				System.out.println(this.getName()+"      a");
			}
		}.start();
		
		new Thread(new Runnable() {
    
    
			@Override
			public void run() {
    
    
				//Thread.currentThread获取当前正在执行的线程
	System.out.println(Thread.currentThread().getName()+"     a");
			}
		}).start();
		Thread.currentThread().setName("我是主线程");
		System.out.println(Thread.currentThread().getName());
	}

效果如下：
在这里插入图片描述

十、休眠线程

顾名思义，就是让线程睡一会儿。慢一点执行。因为计算机CPU执行速度很快。输出结果可能几纳秒就计算结束。休眠线程可以理解为让当前线程睡一会。执行慢一点。
Thread.sleep(毫秒,纳秒)，控制当前线程休眠若干毫秒1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000

public static void main(String[] args) throws InterruptedException {
    
    
		for (int i = 20; i >=0; i--) {
    
    
			Thread.sleep(1000);
			System.out.println("倒计时第"+i+"秒");
		}
	}

效果如下：此时每一秒都会执行一次线程。
在这里插入图片描述

new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 10; i++) {
    
    
					try {
    
    
						Thread.sleep(1000);
					} catch (InterruptedException e) {
    
    
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(this.getName()+ "        a");
	}
			}
}.start();
		new Thread(new Runnable() {
    
    
			public void run() {
    
    
				try {
    
    
					Thread.sleep(1000);
				} catch (InterruptedException e) {
    
    
					e.printStackTrace();
				}
				for (int i = 0; i < 10; i++) {
    
    
					System.out.println(Thread.currentThread().getName()+"    b");
				}	
			}
}).start();

上面这段代码是用runnable接口实现一个线程在书写一遍。

十一、守护线程

setDaemon()，设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出。

Thread t1=new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 2; i++) {
    
    
					System.out.println(getName()+"     a");
				}
			}
		};
Thread t2=new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 50; i++) {
    
    
					System.out.println(getName()+"          b");
				}
			}
		};
		t2.setDaemon(true); 			
		//当传入true意味着设置为守护线程
		t1.start();
		t2.start();

效果如下：
在这里插入图片描述此时我们会发现，当我们线程0执行两次，线程1依旧执行了6次。很好理解。理论上当我们用QQ给别人发送文件时，我们关闭聊天窗口，这时传送数据应该会立即执行关闭。但是，当我们关闭聊天窗口，传送文件的这个线程，依旧在执行。这就是所谓的延迟缓冲效果。QQ聊天窗口与传送文件就是守护与被守护的关系

十二、加入线程

相当于插队

join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
join(int), 可以等待指定的毫秒之后继续

public static void main(String[] args) {
    
    
		final Thread t1=new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 10; i++) {
    
    
					System.out.println(getName()+"     aaaaaa");
				}
			}
		};
		
		Thread t2=new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 10; i++) {
    
    
					if (i==2) {
    
    
						try {
    
    
							//t1.join();
							t1.join(1);			
//插队指定的使劲，过了指定时间后，两条线程交替执行
						} catch (InterruptedException e) {
    
    
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					System.out.println(getName()+"   bbbbbbbb");
				}
			}
		};
		t1.start();
		t2.start();
	}

效果如下：
在这里插入图片描述此时我们会发现，当我们不传入参数的时候，线程1在执行两次输出b的时候，线程0会优先插队进入在进行1之后。当我们传入参数的时候，意思就是进行0会执行多少毫秒。比如，当i=2的时候，进程0会优先执行1毫秒。
并且注意此时的t1的作用范围是final，因为花括号表示一个局部的作用范围。所以并不能将t1运用到t2的作用范围之中

十三、礼让线程

yield让出cpu，当前线程会暂定让出CPU。给别的进程进行执行。

public static void main(String[] args) {
    
    
			new MyThread().start();
			new MyThread().start();
	}

}
class MyThread extends Thread{
    
    
	public void run() {
    
    
		for (int i = 0; i <=1000; i++) {
    
    
			if (i%10==0) {
    
    
				Thread.yield();		//让出CPU			
			}
			System.out.println(getName()+"           "+i);
		}
		
	}

效果如下：
当某一线程达到10的时候，会进行将CPU让出给另外一个线程去执行。
在这里插入图片描述

十四、设置线程的优先级

setPriority() 设置线程的优先级。java中最小线程的级别是1，最高级别的线程是10。不去设置线程的话，它的优先级别就是5.

public final static int MIN_PRIORITY =  1//源码中设置最小的优先级是1
public final static int NORM_PRIORITY = 5;//源码中设置普通优先级是5
public final static int MAX_PRIORITY = 10;//源码中设置最大的优先级是10

Thread t1=new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 1000; i++) {
    
    
					System.out.println(getName()+"     a");
				}
			}
		};
Thread t2=new Thread() {
    
    
			public void run() {
    
    
				for (int i = 0; i < 1000; i++) {
    
    
					System.out.println(getName()+"  b");
				}
			}
		};
		
	   t1.setPriority(10);
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.setPriority(1);
		t2.setPriority(Thread.MIN_PRIORITY);
			///两种写法一个即可	
		t1.start();
		t2.start();

效果如下：
线程0也就是输出a的明显比线程1也就是输出b的要多得多，因为优先级别比较高

十五、同步代码块

1.什么情况下需要同步

当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

2.同步代码块

使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块。
多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
未使用synchronized之前

final Printer printer=new Printer();
		new Thread() {
    
    
			public void run(){
    
    
				while (true) {
    
    
					printer.print1();
				}
			}
		}.start();
		new Thread() {
    
    
			public void run(){
    
    
				while (true) {
    
    
					printer.print2();
				}
			}
		}.start();
	}

}

class Printer{
    
    
	public void print1(){
    
    
		System.out.print("我");
		System.out.print("是");
		System.out.print("小");
		System.out.print("学");
		System.out.print("生");
		System.out.print("\r\n");
	}
	public void print2(){
    
    
		System.out.print("我");
		System.out.print("是");
		System.out.print("大");
		System.out.print("学");
		System.out.print("生");
		System.out.print("\r\n");
	}

此时我们可能会出现断续的情况，也就是输出会进行插叙。是因为当我们执行print1（）的时候，CPU可能会抢占资源，使用print2（）方法。此时，我们希望在输出print1的时候，print2不进行输出。这就需要运用到同步机制。

public static void main(String[] args) {
    
    
		final Printer printer=new Printer();
		new Thread() {
    
    
			public void run(){
    
    
				while (true) {
    
    
					printer.print1();
				}
			}
		}.start();
		new Thread() {
    
    
			public void run(){
    
    
				while (true) {
    
    
					printer.print2();
				}
			}
		}.start();
	}

}
class Printer{
    
    
	Demo d =new Demo();
	public void print1(){
    
    
		synchronized (d) {
    
    		
//同步代码块，锁机制，锁对象可以是任意的
			System.out.print("我");
			System.out.print("是");
			System.out.print("小");
			System.out.print("学");
			System.out.print("生");
			System.out.print("\r\n");	
		}	
	}
	public void print2(){
    
    
		synchronized (d) {
    
    		
//锁对象不能用匿名对象，因为匿名对象不是同一个对象
			System.out.print("我");
			System.out.print("是");
			System.out.print("大");
			System.out.print("学");
			System.out.print("生");
			System.out.print("\r\n");
		}		
	}
}
class Demo{
    
    
	//锁对象
}

注意几点：
第一：我们在最后需要设置一个任意的对象，把他当作一种锁，以此这样来实现进程同步。
第二我们设置锁锁对象不能用匿名对象（new Object()），因为匿名对象不是同一个对象。

十六、同步方法（静态方法和非静态方法）

使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的
同步方法只需要在方法上加synchronized关键字即可
非静态同步方法：

class Printer2{
    
    
	Demo d =new Demo();
	//非静态的同步方法的锁对象是什么？
	//答：非静态的同步方法的锁对象是this
	public synchronized void print1(){
    
    	
//同步方法只需要在方法上加synchronized关键字即可
			System.out.print("我");
			System.out.print("是");
			System.out.print("小");
			System.out.print("学");
			System.out.print("生");
			System.out.print("\r\n");			
	}
	public  void print2(){
    
    	
		synchronized (this){
    
    
			System.out.print("我");
			System.out.print("是");
			System.out.print("大");
			System.out.print("学");
			System.out.print("生");
			System.out.print("\r\n");
		}	
	}
}

问：非静态的同步方法的锁对象是什么？
答：非静态的同步方法的锁对象是this
静态同步方法：

class Printer2{
    
    
	Demo d =new Demo();
	//静态的同步方法的锁对象是什么？？
	//是该类的字节码对象
	public static synchronized void print1(){
    
    	
//同步方法只需要在方法上加synchronized关键字即可
			System.out.print("我");
			System.out.print("是");
			System.out.print("小");
			System.out.print("学");
			System.out.print("生");
			System.out.print("\r\n");			
	}
	public  void print2(){
    
    	
		synchronized (Printer2.class){
    
    
			System.out.print("我");
			System.out.print("是");
			System.out.print("大");
			System.out.print("学");
			System.out.print("生");
			System.out.print("\r\n");
		}	
	}
}

问：静态的同步方法的锁对象是什么？？
答：是该类的字节码对象

十七、线程安全问题

多线程并发操作同一数据时, 就有可能出现线程安全问题
使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作

我们通过一个案例来体现该问题，需求：铁路售票，一共100张，，通过四个窗口卖完
方法一： Thread方法

主函数：开启四个线程
public static void main(String[] args) {
    
    
		// TODO Auto-generated method stub
			new Ticket().start();
			new Ticket().start();
			new Ticket().start();
			new Ticket().start();
	}

车票类方法

class Ticket extends Thread{
    
    
	private static int ticket =100;
	public void run() {
    
    
		while (true) {
    
    
		synchronized (Ticket.class) {
    
    		
			if (ticket <= 0) {
    
    
				break;
			}
			try {
    
    
				Thread.sleep(10);
			} catch (InterruptedException e) {
    
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(getName()+"------这是第"+ticket--+"号票");
		}
	}
}

细节太多建议反复观看，

首先ticket为什么要设置static，因为有四个线程对同一个数据进行处理。所以数据要进行统一，否则创建四个线程，每个线程票数都会是从100开始。
其次，我们需要票数判断中进行synchronized 该处我们需要对票数进行同步，因为我们想要实现多进行对一个数据进行改变的时候，需要进行同步。否则ticket会在进行赋值和自减之间出现问题。
我们的锁使用的是Ticket.class 如果我们使用this关键字，那么不会进行同步，因为Thread有4个对象。

方法二：火车站卖票的例子用实现Runnable接口

public static void main(String[] args) {
    
    
		MyTicket myTicket=new MyTicket();
		new Thread(myTicket).start();
		new Thread(myTicket).start();
		new Thread(myTicket).start();
		new Thread(myTicket).start();
	}

车牌类方法

class MyTicket implements Runnable{
    
    
	private int tickets =100;
	@Override
	public void run() {
    
    
		// TODO Auto-generated method stub
		while (true) {
    
    
			synchronized (this) {
    
    
				if (tickets<=0) {
    
    
					break;
}
				try {
    
    
					Thread.sleep(10);
				} catch (InterruptedException e) {
    
    
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"这是第"+tickets--+"号票");
			}
			
		}

细节太多，建议反复观看

此处的tickets的票数并没有设置静态的原因是我们的runable接口创建线程，不需要创建四个对象。将本身当作资源传递给Thread的构造函数new Thread(myTicket).start()。
锁对象可不可以用this。因为我们只创建了一个对象，this 表示的就是 myTicket

十八、多线程的死锁

多线程同步的时候, 如果同步代码嵌套, 使用相同锁, 就有可能出现死锁
尽量不要嵌套使用

我们对哲学家问题进行思考

private static String s1="筷子左";
	private static String s2="筷子右";
	public static void main(String[] args) {
    
    
		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					synchronized (s1) {
    
    
						System.out.println(getName()+"获取"+s1+"等待"+s2);
					}synchronized (s2) {
    
    
						System.out.println(getName()+"拿到"+s2+"等待"+"开吃");
					}
				}
			}
		}.start();
		
		
		new Thread() {
    
    
			public void run() {
    
    
				while (true) {
    
    
					synchronized (s2) {
    
    
						System.out.println(getName()+"获取"+s2+"等待"+s1);
					}synchronized (s1) {
    
    
						System.out.println(getName()+"拿到"+s1+"等待"+"开吃");
					}
				}
			}
		}.start();
	}

这两个线程发生死锁，原因是第一个线程有左筷子之后有拿到右筷子开吃。此时第二个进程有右筷子，但是他又申请左筷子。此时，他们都抢占这右筷子。谁也不让谁。

十九、其他

回顾以前说过的线程安全问题，我们可以看以前的集合以及String类都有设置线程安全或不安全的代码

看源码：
Vector,StringBuffer,Hashtable,Collections.synchroinzed(xxx)
Vector是线程安全的,ArrayList是线程不安全的
StringBuffer是线程安全的,StringBuilder是线程不安全的
Hashtable是线程安全的,HashMap是线程不安全的