面向对象---多线程（上）

一、概念

1、线程与进程

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

  简而言之：一个软件中至少有一个应用程序，应用程序的一次运行就是一个进程，一个进程中至少有一个线程。

• 进程是操作系统调度和分配资源的最小单位，线程是CPU调度的最小单位

• 不同进程之间是不共享内存的。不同线程是共享同一个进程的内存的，不同的线程有自己独立的内存空间。

2、并发和并行

• 并行（parallel）：指两个或多个事件在同一时刻发生（同时发生）。指在同一时刻，有多条指令在多个处理器上同时执行。

• 并发（concurrency）：指两个或多个事件在同一个时间段内发生。指在同一个时刻只能有一条指令执行，但多个进程的指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。

• 单核CPU只能并发，多核CPU能并发也能并行。

3、线程调度

• 分时调度

  所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

• 抢占式调度

  优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

二、另行创建和启动线程

当运行Java程序时，其实已经有一个线程了，那就是main线程。需要创建和启动main线程以外的线程。

1、继承Thread类

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java通过继承Thread类来创建并启动多线程步骤如下：

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。

2. 创建Thread子类的实例，即创建了线程对象

3. 调用线程对象的start()方法来启动该线程

2、实现Runnable接口

Java有单继承的限制，当我们无法继承Thread类时，我们可以使用Runnable接口，重写run()方法，然后再通过Thread类的对象代理启动和执行我们的线程体run()方法步骤如下：

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。

2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正 的线程对象。

3. 调用线程对象的start()方法来启动线程。

3、使用匿名内部类对象来实现现成的创建和启动

    new Thread("新的线程！"){
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(getName()+"：正在执行！"+i);
            }
        }
    }.start();

    new Thread(new Runnable(){
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()+"：" + i);
            }
        }
    }).start();

三、Thread类

1、构造方法

• public Thread() :分配一个新的线程对象。

• public Thread(String name) :分配一个指定名字的新的线程对象。

• public Thread(Runnable target) :分配一个带有指定目标新的线程对象。

• public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

2、常用方法

• public void run() :此线程要执行的任务在此处定义代码。

• public String getName() :获取当前线程名称。

• public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

• public final int getPriority() ：返回线程优先级

• public final void setPriority(int newPriority) ：改变线程的优先级，setPriority方法需要一个整数，并且范围在[1,10]之间，通常有三个优先级。

• MAX_PRIORITY（10）：最高优先级

• MIN _PRIORITY （1）：最低优先级

• NORM_PRIORITY （5）：普通优先级，默认情况下main线程具有普通优先级。

	public static void main(String[] args) {
		Thread t = new Thread(){
			public void run(){
				System.out.println(getName() + "的优先级：" + getPriority());
			}
		};
		t.setPriority(Thread.MAX_PRIORITY);
		t.start();
		
		System.out.println(Thread.currentThread().getName() +"的优先级：" + Thread.currentThread().getPriority());
	}

• public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

• public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

• public static void yield()：yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

• void join() ：等待该线程终止。

  void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒。如果millis时间到，将不再等待。

  void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。

• public final boolean isAlive()：测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态

3、守护线程

• 有一种线程，它是在后台运行的，它的任务是为其他线程提供服务的，这种线程被称为“守护线程”。JVM的垃圾回收线程就是典型的守护线程。
• 守护线程有个特点，就是如果所有非守护线程都死亡，那么守护线程自动死亡。
• 调用setDaemon(true)方法可将指定线程设置为守护线程。必须在线程启动之前设置，否则会报IllegalThreadStateException异常。
• 调用isDaemon()可以判断线程是否是守护线程。

public class TestThread {
	public static void main(String[] args) {
		MyDaemon m = new MyDaemon();
		m.setDaemon(true);
		m.start();

		for (int i = 1; i <= 100; i++) {
			System.out.println("main:" + i);
		}
	}
}

class MyDaemon extends Thread {
	public void run() {
		while (true) {
			System.out.println("守护线程");
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

四、线程安全

1、线程安全问题

当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，若多个线程只有读操作，那么不会发生线程安全问题，但是如果多个线程中对资源有读和写的操作，就容易出现线程安全问题。

1、局部变量不能共享（局部变量是每次调用方法都是独立的，那么每个线程的run()的total是独立的，不是共享数据。 ）

2、不同对象的实例变量不共享（不同的实例对象的实例变量是独立的。 ）

3、静态变量共享

4、同一个对象的实例变量共享

5、抽取资源类，共享同一个资源对象

2、尝试解决线程安全问题

2.1Java中提供了同步机制 (synchronized)来解决。

同步解决线程安全的原理：

同步机制的原理，其实就相当于给某段代码加“锁”，任何线程想要执行这段代码，都要先获得“锁”，我们称为它同步锁。

2.2 同步代码块和同步方法

同步方法：synchronized 关键字直接修饰方法，表示同一时刻只有一个线程能进入这个方法，其他线程在外面等着。

public synchronized void method(){
    可能会产生线程安全问题的代码
}

同步代码块：synchronized 关键字可以用于某个区块前面，表示只对这个区块的资源实行互斥访问。

synchronized(同步锁){
     需要同步操作的代码
}

2.3同步锁对象的选择

同步锁对象可以是任意类型，但是必须保证竞争“同一个共享资源”的多个线程必须使用同一个“同步锁对象”。

对于同步代码块来说，同步锁对象是由程序员手动指定的，但是对于同步方法来说，同步锁对象只能是默认的，

• 静态方法：当前类的Class对象

• 非静态方法：this

2.4同步代码的范围选择

锁的范围太小：不能解决安全问题

锁的范围太大：因为一旦某个线程抢到锁，其他线程就只能等待，所以范围太大，效率会降低，不能合理利用CPU资源。