进程与线程

进程与线程

​ 系统中每执行了一个程序,就相当开启了一个进程.进程有独立的内存空间和系统资源.我们在任务管理器中就能看到每一条进程信息,并且可以强制关闭进程.

​ 而每个进程中,可以有一条或多条线程.线程是进程执行运算的最小单位,可完成一个独立的顺序控制流程,是CPU调度和分派的基本单位.

多线程

​ 如果在一个进程中同时运行了多个线程,用来完成不同的工作,则称之为"多线程"。多个线程交替占用CPU资源（以毫秒为单位），而非真正的并行执行。

多线程的好处：

1、充分利用CPU的资源

2、简化编程模型

3、带来良好的用户体验

主线程

Thread类

​ Java提供了java.lang.Thread类支持多线程编程。

​ 在程序中，main()方法即为主线程入口，主线程中可以产生其他子线程，但主线程必须在所有子线程的最后完成执行，因为它执行各种关闭动作。

线程的创建和启动

​ 在java中创建线程有两种方式：

​ 1、继承java.lang.Thread类

​ 2、实现java.lang.Runnable接口

​ 使用线程的步骤：

​ 1、定义线程（自定义类继承Thread类或者实现Runnable接口，并重写run()方法）

​ 2、创建线程对象（实例化线程对象）

​ 3、启动线程（start()方法交替使用线程）

​ 4、终止线程

继承Thread类创建线程

​ （1）定义一个自定义类（如MyThread类）继承Thread类

​ （2）重写run()方法，编写线程执行体（不重写编译不会报错）

​ （3）创建线程对象，调用start()方法启动线程（启动后线程处于待定状态，等待cpu分配资源启动）

	public class MyThread extends Thread{
        //重写run()方法
        public void run(){
            for(int i=1;i<100;i++){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }

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

​ 创建完线程对象后，通过start()方法交替使用线程，而不是用run()方法。如果直接运行run()方法，就变成了主线程一条路径调用普通方法了，只有使用start()方法才能启动多个子线程。线程每次执行时长由分配的CPU时间片长度决定。

实现Runnable接口创建线程

（1）定义自定义类（如MyRunnable类）实现Runnable接口

（2）实现run()方法，编写线程执行体（不实现会报错）

（3）创建线程对象，调用start()方法启动线程

	public class MyRunnable implements Runnable{
        public void run(){
            for(int i=1;i<100;i++){
                System.out.println(Thread.currentTrhead().getName()+":"+i);
            }
        }
    }

		public static void main(String[]args){
        	MyRunnable myRunnable = new MyRunnable();
            Thread myThread = new Thread(myRunnable);
            myThread.start();
    }

两种创建线程方式的特点：

（1）继承Thread类

​ 1、编写简单，可直接操作线程。

​ 2、适用于单继承

（2）实现Runnable接口

​ 1、避免单继承局限性

​ 2、便于共享资源

推荐使用实现Runnable接口的方式创建线程。

线程的状态

​ 一个线程的生命周期可以划分为5种状态，分别是：

​ 1、创建状态

​ 实例化线程对象或者main()方法开始时，即为线程创建状态

​ 2、就绪状态

​ （1）通过start()方法启动线程后，线程进入就绪状态
​ （2）运行状态的线程释放掉CPU资源后，进入就绪状态
​ （3）阻塞状态的线程解除阻塞后，进入就绪状态

​ 3、运行状态

​ 线程获得CPU资源后，进入运行状态

​ 4、阻塞状态

​ 运行状态下的线程可能会因为多种原因，进入阻塞状态。
​ 如：等待用户输入、线程休眠等情况

​ 5、死亡状态

​ （1）线程自然执行完毕

​ （2）外部干涉终止线程

线程的调度

​ 线程调度指按照特定机制为多个线程分配CPU的使用权，有以下几个方法：

返回值类型	方法名	说明
void	setPriority(int newPriority)	更改线程的优先级
void	sleep(long millis)	静态方法，在指定的毫秒数内让当前正在执行的线程休眠
void	join()	等待线程终止
void	yield()	暂停当前正在执行的线程对象，并执行其他线程
void	interrupt()	中断线程
boolean	isAlive()	测试线程是否处于活动状态

（1）setPriority(int newPriority)

​ 线程优先级由1~10表示，1为最低，10为最高，默认优先级为5。优先级别高的线程获得CPU资源的概率较大，但不能保证优先级别高的线程一定先获得CPU资源。

Thread中有三个表示优先级的静态常量，分别是：

MAX_PRIORITY，常量值为10；

MIN_PRIORITY，常量值为1；

NORMAL_PRIORITY，常量值为5.

（2）static void sleep(long millis)

​ 是一个静态方法，在指定的毫秒数内让当前正在执行的线程休眠
​ 让线程暂时休眠指定时长，线程进入阻塞状态，睡眠时间过后线程会再进入可运行状态
​ 调用sleep()方法需处理InterruptedException异常

（3）void join()

​ 使当前线程暂停执行，等待指定的其他线程结束后再继续执行本线程，暂停过程中，其他的线程可与指定的线程互相竞争cpu资源。

​ 有三种重载方法：

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

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

（4）public static void yield()

​ 暂停当前线程，允许其他具有相同优先级别的线程获得运行机会。该线程处于就绪状态，不转为阻塞状态
​ public static void yield(); 是一个静态方法
​ 只是提供一种可能，但是不能保证一定会实现礼让

线程同步

​ 当多个线程共享一个资源时，一个线程未完成全部操作的时候，其他线程修改数据，会造成数据不安全的问题。
​ 线程操作：
​ （1）修改数据
​ （2）显示数据

​ 使用线程同步的方式，就能让一个线程单独操作数据，避免了数据不安全的问题。

​ 线程同步有两种方式，一种是同步方法，一种是同步代码块。两种方式都用到了synchronized关键字。

（1）同步方法

​ 使用synchronized修饰的方法控制对类成员变量的访问。将代码上锁（封装成方法），只允许一个线程进来操作共享数据。

​ 同步方法语法格式：

​ 访问修饰符 synchronized 返回值类型 方法名 （参数列表）{}
​ 或
​ synchronized 访问修饰符 返回值类型 方法名 （参数列表）{}

​ 定义同步方法–>run()方法中调用同步方法

（2）同步代码块

​ 使用synchronized关键字修饰的代码块

		synchronized( syncObject ){
		  //需同步的代码
		}

​ syncObject为需同步的对象，通常为this
​ 效果与同步方法相同

​ syncObject为需同步的对象，通常为this
​ 效果与同步方法相同

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

线程安全

ArrayList类的add()方法

​ 定义：

public boolean add(E e){
    ensureCapacityInternal(size +1); //集合扩容，确保能新增数据
    elementData[size++]=e;   //在新增位置存放数据
     return true;
}

可以看出，ArrayList类的add()方法为非同步方法。当多个线程向同一个ArrayList对象添加数据时，可能出现数据不一致问题。

所以ArrayList为非线程安全的类型。

如果一个类里有同步方法或同步代码块，那么这个类就是一个线程安全的类

	方法是否同步	效率比较	适合场景
线程安全	是	低	多线程并发共享资源
非线程安全	否	高	单线程

为了达到安全性和效率的平衡，可以根据实际场景来选择合适的类型。

Hashtable和HashMap类

Hashtable类实现了Map接口，继承Dictionary类，它是一个线程安全的类，效率比较低，并且键和值都不允许为null.

HashMap类实现了Map接口，继承AbstractMap类，它是一个非线程安全的类，效率比较高，并且键和值都允许为null.

StringBuffer和StringBuilder类

StringBuffer类是线程安全的类型，效率较低

StringBuilder类是非线程安全的类型，效率较高