多线程学习笔记一

1.多线程的引入

1.1. 什么是线程

• 线程是程序执行的一条路径, 一个进程中可以包含多条线程
• 多线程并发执行可以提高程序的效率, 可以同时完成多项工作

1.2.多线程的应用场景

• 红蜘蛛同时共享屏幕给多个电脑
• 迅雷开启多条线程一起下载
• QQ同时和多个人一起视频
• 服务器同时处理多个客户端请求

2.多线程并行和并发的区别

2.1并行

• 并行就是两个任务同时执行，执行A任务的同时执行B任务
• 比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行

2.2并发

• 并发是指两个任务同时请求执行，但是处理器只能处理一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
• 如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。
• cpu执行任务是并发，底层实际还是单线程，具体的时间段执行的还是一个任务

3.JAVA程序运行和JVM的启动是多线程？

3.1Java程序运行原理

• Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。

3.2JVM的启动是多线程的吗

• JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

public class JVM_Thread {
	
	/**
	 * JVM是多线程的，垃圾回收线程和主线程互相抢夺资源，交替执行
	 * @param args
	 */
	public static void main(String[] args) {
		//垃圾回收线程的执行
		for (int i = 0; i < 1000000; i++) {
			new Demo();
		}
		//主线程的执行
		for (int i = 0; i < 100000; i++) {
			System.out.println("这是主线程");
		}
	}
}
class Demo{
	@Override
	public void finalize() throws Throwable {
		System.out.println("垃圾清理");
	}
}

4.多线程实现的两种方式

4.1. 继承Thread类并重写run()方法

public class CreateThread_01 {

	@Test
	/**
	 * 01:继承Thread类并重写其run()方法
	 */
	public void Demo1(){
		Thread01 thread01 = new Thread01();									//5.创建线程对象
		//thread01.run();		//调用run()方法，就是调用了一个普通的方法，按照顺序执行
		//线程开始执行; Java虚拟机会调用此线程的run方法
		thread01.start();		//只有调用start()方法，才是开启了一个线程，会和主线程争夺线程资源，交替执行		//6.调用start()方法
		for (int i = 0; i < 500; i++) {
			System.out.println("主线程");
		}
	}
}

class Thread01 extends Thread{						//1.定义类继承Thread
	@Override
	public void run() {								//2.重写run()方法
		for (int i = 0; i < 100; i++) {				//3.实现的方法，在run()方法中
			System.out.println("这是继承了Thread类并重写了run()方法的线程的执行方法");	
		}
	}
}

4.2. 实现Runnable接口并重写run()方法

public class CreateThread_02 {

	public static void main(String[] args) {
		Runnable02 runnable02 = new Runnable02();			//4.创建Runnable的子类对象
		Thread thread = new Thread(runnable02);				//5.创建线程(将Runnable的子类对象当作参数传递,根据Thread(Runnable target)构造方法创建)
		thread.start();										//6.调用线程的start()方法开启线程
		for (int i = 0; i < 100; i++) {		
			System.out.println("主线程执行");
		}
	}
}

class Runnable02 implements Runnable{				//1.定义一个类实现Runnable
	@Override
	public void run() {								//2.重写run()方法
		for (int i = 0; i < 100; i++) {				//3.实现的方法，在run()方法中
			System.out.println("这是实现了Runnable的run()方法的线程的执行方法");
		}
	}
}

4.3 匿名内部类创建线程的两种方式

	public static void main(String[] args) {
		//01:继承Thread类的匿名内部类的方式创建线程
		new Thread(){									//1.继承Thread类
			@Override				
			public void run() {							//2.重写run()方法
				for (int i = 0; i < 100; i++) {			//3.实现的功能写在run()方法里		
					System.out.println("------这是继承Thread类的线程创建的匿名内部类------");
				}
			}
		}.start();										//4.开启线程
		//02:实现Runnable接口的匿名内部类的方式创建线程
		new Thread(new Runnable() {						//1.将Runnable的子类对象当作参数调用Thread的构造方法
			@Override	
			public void run() {							//2.重写run()方法
				for (int i = 0; i < 100; i++) {			//3.实现的功能写在run()方法里
					System.out.println("这是实现Runnable接口的线程创建的匿名内部类");
				}
			}
		}).start();										//4.开启线程
	}

4.4 Runnable的实现原理

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

4.5 线程实现的两种方式的区别

• 查看源码的区别:
  • a.继承Thread : 由于子类重写了Thread类的run(), 当调用start()时, 直接找子类的run()方法
  • b.实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run(),运行时执行的是子类的run()方法
• 继承Thread
  • 好处是:可以直接使用Thread类中的方法,代码简单
  • 弊端是:如果已经有了父类,就不能用这种方法
• 实现Runnable接口
  • 好处是:即使自己定义的线程类有了父类也没关系,因为有了父类也可以实现接口,而且接口是可以多实现的
  • 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂

5.获取线程名字、设置名字和获取线程对象

5.1 获取线程名字调用getName()方法

ublic void getThreadName() {
		// 第一个线程对象
		new Thread() {
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(this.getName() + "----aaaa----");
				}
			}
		}.start();
		// 第二个线程对象
		new Thread() {
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(this.getName() + "----bbbb----");
				}
			}
		}.start();
	}

5.2 设置线程名字两种方式

• 01:构造方法设置

public void setThreadName01() {
		new Thread("---线程A---") {
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(this.getName() + "线程A");
				}
			};
		}.start();
		new Thread("---线程B---") {
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(this.getName() + "线程B");
				}
			};
		}.start();
	}

• 02:set方法设置

public void setThreadName02() {
		// 创建第一个线程
		Thread thread01 = new Thread() {
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(this.getName() + "线程A");
				}
			};
		};
		// 创建第二个线程
		Thread thread02 = new Thread() {
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(this.getName() + "线程B");
				}
			}
		};
		thread01.setName("---线程A---");
		thread02.setName("---线程B---");
		thread01.start();
		thread02.start();
	}

5.3 获取线程对象currentThread()方法

public static void main(String[] args) {
		//开启一条继承Thread类的线程
		new Thread(){
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"------aaaaaa");
			}
		}.start();
		//开启一条实现Runnable接口的线程
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName()+"-----bbbbb");
			}
		}).start();
		//获取主线程对象名称
		System.out.println(Thread.currentThread().getName()+"------main(修改前)");
		//获取主线程对象，修改线程名
		Thread.currentThread().setName("我是主线程");
		//获取修改后的线程对象名称
		System.out.println(Thread.currentThread().getName()+"------main(修改后)");
	}

6. 线程操作

6.1 休眠线程(控制当前线程休眠若干纳秒)

public static void main(String[] args) {
		//创建一条线程
		new Thread() {
			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					try {				//父类没有抛出异常，子类不能抛出异常，只能try-catch
						//线程休眠1秒
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "------aaaa");
				}
			}
		}.start();
		//创建一条线程
		new Thread(new Runnable() {
			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					try {
						//线程休眠1秒
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "----------bbbb");
				}
			}
		}).start();
	}

6.2 守护线程

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

public static void main(String[] args) {
		Thread thread01 = new Thread(){
			@Override
			public void run() {
				for (int i = 0; i < 2; i++) {
					System.out.println(getName()+"-----aa");
				}
			}
		};
		Thread thread02 = new Thread(){
			@Override
			public void run() {
				for (int i = 0; i < 20; i++) {
					System.out.println(getName()+"-----bb");
				}
			}
		};
		//设置thread02为守护线程，thread01线程结束之后，thread02自动挂掉，挂掉有一定延迟
		thread02.setDaemon(true);
		thread01.start();
		thread02.start();
	}

6.3 加入线程

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

public static void main(String[] args) {
		Thread thread01 = new Thread(){
			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println(getName()+"-----aa");
				}
			}
		};
		Thread thread02 = new Thread(){
			@Override
			public void run() {
				for (int i = 0; i < 10; i++) {
					if(i==2){
						try {
							//thread01.join();			//暂停thread02线程，执行完thread01线程后继续执行
							thread01.join(1);		//thread02线程在等待指定时间后继续执行
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
					System.out.println(getName()+"-----bb");
				}
			}
		};
		thread01.start();
		thread02.start();
	}

6.3 礼让线程

• yield()让出cpu

public class YieldThread_10 {

	public static void main(String[] args) {
		new MyThread().start();
		new MyThread().start();
	}
}
class MyThread extends Thread{
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			if(i%10==0){
				Thread.yield();		//让出cpu给另一线程
			}
			System.out.println(getName()+"...."+i);
		}
	}
}

6.4 线程优先级

• setPriority()设置线程优先级

public static void main(String[] args) {
		Thread thread01 = new Thread(){
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(getName()+"------aaaa");
				}
			}
		};
		Thread thread02 = new Thread(){
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(getName()+"------bbbb");
				}
			}
		};
		//thread01.setPriority(10);				//设置线程权限，范围为1-10，1为最小，10为最大，5为默认
		//thread02.setPriority(1);
		thread01.setPriority(Thread.MAX_PRIORITY);			//设置线程权限为最高权限，值为10
		//thread01.setPriority(Thread.NORM_PRIORITY);		//设置线程权限为默认权限，值为5		
		thread02.setPriority(Thread.MIN_PRIORITY);			//设置线程权限为最低权限，值为1
		thread01.start();
		thread02.start();
	}

7. 线程同步

7.1 同步代码块

• 1.什么情况下需要同步
  • 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
  • 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
• 2.同步代码块
  • 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
  • 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的(锁对象是任意对象)

public class SynchronizedThread_12 {
	public static void main(String[] args) {
		Printer p = new Printer();
		//创建第一条线程，调用第一条打印
		new Thread(){
			@Override
			public void run() {
				for (int i = 0; i <100; i++) {
					p.print01();
				}	
			}
		}.start();
		//创建第二条线程，调用第二条打印
		new Thread(){
			@Override
			public void run() {
				for (int i = 0; i <100; i++) {
					p.print02();
				}	
			}
		}.start();
	}	
}

class Printer{
	Object a = new Object();
	public void print01(){	
		//synchronized (new Object()) {						//锁对象不能使用匿名内部类，因为匿名内部类是不同对象
		synchronized (a) {					//使用同步代码块，锁机制，锁对象可以是任意对象，多个同步代码块使用同一个锁对象，那么就是同步的
			System.out.print("多");
			System.out.print("线");
			System.out.print("程");
			System.out.print("\r\n");
		}
	}
	public void print02(){
		synchronized (a) {
			System.out.print("同");
			System.out.print("步");
			System.out.print("\r\n");
		}
	}	
}

7.2 同步方法

• 使用synchronized关键字修饰一个方法, 该方法中所有的代码都是同步的

public class SynchronizedThread_13 {
	public static void main(String[] args) {
		Printer02 p = new Printer02();
		new Thread() {
			public void run() {
				for (int i = 0; i < 100; i++) {
					p.print01();
				}
			};
		}.start();
		new Thread() {
			public void run() {
				for (int i = 0; i < 100; i++) {
					p.print02();
				}
			};
		}.start();
	}
}

class Printer02 {
	// 同步方法非静态方法的锁对象是this
	// 同步方法静态方法的锁对象是当前类的字节码即为Printer02.class
	public static synchronized void print01() {
		System.out.print("多");
		System.out.print("线");
		System.out.print("程");
		System.out.print("\r\n");
	}
	public static void print02() {
		// synchronized (this) { 					//同步方法非静态方法的锁对象为this
		synchronized (Printer02.class) {			//同步方法静态方法的锁对象为当前类的字节码即为Printer02.class
			System.out.print("同");
			System.out.print("步");
			System.out.print("\r\n");
		}
	}
}

7. 线程安全

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

7.1 案例:火车站四个窗口共卖一百张票（继承Thread类创建线程）

public class SafeThread_14 {

	//创建四条线程模拟四个窗口
	public static void main(String[] args) {
		new Ticket().start();
		new Ticket().start();
		new Ticket().start();
		new Ticket().start();
	}
}
class Ticket extends Thread{
	private static int ticket = 100;			//初始化票余数
	@Override
	public void run() {
		while(true){
			synchronized (Ticket.class) {			//卖票操作实现同步，同步代码块，传入的锁对象为当前类的字节码，保证锁对象一致
				if(ticket<=0){						
					break;
				}
				try {
					Thread.sleep(10);					//使线程休眠
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(getName()+"----这是第"+ticket--+"号票");
			}
		}
	}
}

7.2 案例:火车站四个窗口共卖一百张票（实现Runnable接口创建线程）

public class SafeThread_15 {
	
	public static void main(String[] args) {
		Ticket02 ticket02 = new Ticket02();
		new Thread(ticket02).start();
		new Thread(ticket02).start();
		new Thread(ticket02).start();
		new Thread(ticket02).start();
	}	
}
class Ticket02 implements Runnable{
	private static int ticket = 100;				//初始化票数
	@Override
	public void run() {
		while(true){
			synchronized (this) {					//同步代码块传入锁对象可以为this,也可以为该类的字节码对象，即为Ticket02.class
				if(ticket<=0){						
					break;
				}
				try {
					Thread.sleep(10);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"-----这是第"+ticket--+"号票");
			}
		}
	}
}

8.以往线程安全总结(看源码)

• Vector线程安全 和 Arraylist线程不安全
• HashMap线程不安全 和 HashTable线程安全
• StringBuffer线程安全 和 StringBuilder线程不安全