多线程

进程和线程

进程: 应用程序的执行实例，有独立的内存空间和系统资源。
线程: CPU调度和分派的基本单位，进程中执行运算的最小的单位，可完成一个独立的顺序控制流程。

多线程

1. 如果在一个进程中同时运行了多个线程，用来完成不同的工作，则称之为"多线程"
2. 多个线程交替占用CPU资源，而非真正的并行执行

多线程的好处:

1. 充分利用了CPU的资源
2. 简化编程模型
3. 带来了良好的用户体验

主线程

1. main()方法即为主线程入口
2. 产生其他子线程的线程
3. 必须最后完成执行，因为它执行各种关闭动作

使用线程的步骤 : 定义线程→创建线程对象→启动线程→终止线程

继承Thread类创建线程:

1. 定义MyThread类继承Thread类
2. 重写run()方法，编写线程执行体
3. 创建线程对象，调用start()方法启动线程

常见问题: 启动线程要用start(),不要用run()方法。

1. 主线程调用run()相当于只有主线程一条执行路径。
2. 主线程调用start()相当于多条执行路径，主线程和子线程并行交替执行。

实现Runnable接口创建线程:

1. 定义MyRunnable类实现Runnable接口
2. 实现run()方法，编写线程执行体
3. 创建线程对象，调用start()方法启动线程

两种创建线程方式的区别:
继承Thread类:

1. 编写简单，可直接操作线程
2. 适用于单继承

实现Runnable接口: (推荐)

1. 避免单继承局限性
2. 便于共享资源

线程的状态:

线程调度
线程调度:按照特定机制为多个线程分配CPU的使用权

线程休眠(sleep)
示例:

public class Wait {
	public static void bySec(long s) {
		for (int i = 0; i < s; i++) {
			System.out.println(i + 1 + "秒");
			try {
				Thread.sleep(1000); //线程休眠一秒
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

线程的强制运行(join)
使当前线程暂停执行，等待其他线程结束后再继续执行本线程

public final void join()
public final void join(long mills)
public final void join(long mills,int nanos)

millis:以毫秒为单位的等待时长
nanos:要等待的附加纳秒时长
需处理InterruptedException异常

示例:

public static void main(String[] args) {
		Thread temp = new Thread(new MyThread());
		temp.start();
		for(int i=0;i<20;i++){
			if(i==5){				
				try {
				    temp.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
                     }
              }			
System.out.println(Thread.currentThread().getName()+"运行："+i);
      }
       //省略代码……
}

线程的礼让:
暂停当前线程，允许其他具有相同优先级的线程获得运行机会
该线程处于就绪状态，不转为阻塞状态

public static void yield()

线程的礼让只是提供一种可能，但是不能保证一定会实现礼让

同步代码块(synchronized):
使用synchronized修饰的方法控制对类成员变量的访问

synchronized就是为当前的线程声明一个锁

多个并发线程访问同一资源的同步代码块时

1. 同一时刻只能有一个线程进入synchronized（this）同步代码块
2. 当一个线程访问一个synchronized（this）同步代码块时，其他synchronized（this）同步代码块同样被锁定
3. 当一个线程访问一个synchronized（this）同步代码块时，其他线程可以访问该资源的非synchronized（this）同步代码

线程安全的类型: