Java多线程基础

文章分两份，第一份主要内容为1-4点

• 1.多线程的概念
• 2.Java程序运行原理
• 3.实现多线程的2种方式
• 4.2种方式的区别
• 5.线程同步（同步锁）
• 6.同步线程之间的通讯

1.多线程的概念
（1）并发和并行
并行：多个CPU实例或是多台机器同时执行一段处理逻辑，是真正的同时。
并发：通过CUP调度算法，让用户看上去同时去执行，实际上从CPU操作层面并不是真正的同时。并发往往需要公共的资源，对公共资源的处理和线程之间的协调是并发的难点。
（2）什么是进程
进程：一个应用程序就是一个进程。
多进程：在操作系统中，能同时运行多个任务程序（并发）。
（3）什么是线程
线程：是操作系统能够进行运算调度的最小单位。
多线程：一个进程中可以并发多个线程，每条线程并行且独立执行不同的任务（提高程序的效率）。
多线程应用场景：服务器同时处理多个用户端请求，教学电脑控屏软件同时共享屏幕给多个电脑。

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

3.实现多线程的2种方式

• （1）.继承Thread类
• （2）.实现Runnable接口

（1）.继承Thread类
1.定义类继承Thread
2.重写run方法
3.把新线程要做的事情写在run方法里
4.创建线程对象
5.开启新线程
以下是四个Demo加强理解
Demo1

Demo2

Demo3

Demo4

（2）实现Runnable接口
1.定义类实现Runnable接口
2.实现run方法
3.把新线程要做的事情写在run方法里
4.创建自定义的Runnable的子类对象
5.创建Thread对象，传入Runnable
6.调用start（）开启新线程
以下是两个Demo加强理解
Demo5

Demo6

4.实现多线程的2种方式的区别
继承Thread：
好处：可以直接使用Thread类中的方法，代码简单。
弊端：如果已经有了父类，就不能使用这种方法。

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

5.线程同步（同步锁）
什么情况下需要同步

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

同步代码块

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

下面来个Demo加深理解

//多线程引发的安全问题(如果同时执行多个线程可能会出现2个线程同时具备CPU的执行资格)-->用同步来解决
//经典案例，买票系统
public class Demo4 {
	public static void main(String[] args) {
		//创建4个售票窗口
		TicketThread t1=new TicketThread("A");
		TicketThread t2=new TicketThread("B");
		TicketThread t3=new TicketThread("C");
		TicketThread t4=new TicketThread("D");
		//开启线程
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}
class TicketThread extends Thread{
	//共享定义100张票
	static int tikets=100;//四个线程共享数据

	public TicketThread(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}
	@Override
	public void run() {
		while (true) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//synchronized:同步，参数：一把锁，锁可以是任何对象，如果有多个需要同步，注意一定要用同一把锁。
	  synchronized ("nihao") {//这里不用this，没有针对性，不是唯一的
		  if(tikets>0){
				System.out.println(Thread.currentThread().getName()+"已售票号"+tikets--);
			}else{
				break;
			}
			}
			
		}
	}
}

6.同步线程之间的通讯
什么时候需要通信

• 多个线程并发执行时，在默认情况下CPU是随机切换线程的
• 如果我们希望他们有规律的执行，就可以使用通信，例如每个线程执行一次打印

怎么通信

• 如果希望线程等待，就调用wait();
• 如果希望唤醒等待的线程，就调用notify()；
• 这两个方法必须在同步代码中执行，并且使用同步锁对象来调用。

下面来个Demo加深理解

//想看到的效果是ABABAB型输出
public class Demo1 {
   public static void main(String[] args) {
	   //创建打印对象
	   final Shuchu sc=new Shuchu();
	new Thread(){
		@Override
		public void run() {
			while (true) {
				try {
					sc.scw1();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
			
			
			
		}
	}.start();
	new Thread(){
		@Override
		public void run() {
			while (true) {
				try {
					sc.scw2();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				
			}
			
		}
	}.start();
}
}
/*等待唤醒机制
 * 在同步对象中锁对象是谁，就用哪个对象来调用wait();
 * 面试题：sleep()和wait()的区别：
 * 1.sleep()方法必须传入参数，参数就是时间，时间到了能自己醒来
 * wait()方法不是必须要传入参数，如果没有参数就等待，如果传入参数就到时间后等待
 * 2.sleep()方法在同步中不释放锁
 * wait()方法在同步中释放锁
 * 
 */
class Shuchu{
	private int flag=1;//定义一个标志位
		
	public void scw1() throws InterruptedException{
		synchronized (this) {
			while(flag!=1){
				this.wait();	
			}
			System.out.print("1");
			System.out.print("2");
			System.out.print("3");
			System.out.print("4");
			System.out.println("5");
			flag=2;
			this.notify();//随机唤醒另外一条线程
		}
		
	}
	public void scw2() throws InterruptedException{
		synchronized (this) {
			while(flag!=2){
				this.wait();
			}
			System.out.print("A");
			System.out.print("B");
			System.out.print("C");
			System.out.print("D");
			System.out.println("E");	
			flag=1;
			this.notify();//随机唤醒另外一条线程
		}
	}
}

面试题：sleep()和wait()的区别：

• 1.sleep()方法必须传入参数，参数就是时间，时间到了能自己醒来
  wait()方法不是必须要传入参数，如果没有参数就等待，如果传入参数就到时间后等待

• 2.sleep()方法在同步中不释放锁
  wait()方法在同步中释放锁