Java多线程学习（一）Java多线程入门

时间  2019-11-16
标签 java 多线程 学习 入门 栏目 Java 繁體版
原文   原文链接

最近听不少面试的小伙伴说，网上每每是一篇一篇的Java多线程的文章，除了书籍没有什么学习多线程的一系列文章。可是仅仅凭借一两篇文章很难对多线程有系统的学习，并且面试的时候多线程这方面的知识每每也是考察的重点，因此考虑之下决定写一系列关于Java多线程的文章。文章参考了高老师的《Java多线程编程核心技术》。力争使用最短的篇幅把Java多线程的知识做以系统的讲述。java

本节思惟导图：面试

思惟导图源文件+思惟导图软件关注微信公众号：“Java面试通关手册”回复关键字：“Java多线程”免费领取。

一 进程和多线程简介

1.1 相关概念

何为线程？数据库

线程与进程类似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程当中能够产生多个线程。与进程不一样的是同类的多个线程共享同一块内存空间和一组系统资源，因此系统在产生一个线程，或是在各个线程之间做切换工做时，负担要比进程小得多，也正由于如此，线程也被称为轻量级进程。编程

何为进程？安全

进程是程序的一次执行过程，是系统运行程序的基本单位，所以进程是动态的。系统运行一个程序便是一个进程从建立，运行到消亡的过程。简单来讲，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每一个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操做系统载入内存中。微信

线程和进程有何不一样？网络

线程是进程划分红的更小的运行单位。线程和进程最大的不一样在于基本上各进程是独立的，而各线程则不必定，由于同一进程中的线程极有可能会相互影响。从另外一角度来讲，进程属于操做系统的范畴，主要是同一段时间内，能够同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。多线程

1.2 多线程

何为多线程？jvm

多线程就是几乎同时执行多个线程（一个处理器在某一个时间点上永远都只能是一个线程！即便这个处理器是多核的，除非有多个处理器才能实现多个线程同时运行。）。几乎同时是由于实际上多线程程序中的多个线程其实是一个线程执行一会而后其余的线程再执行，并非不少书籍所谓的同时执行。ide

为何多线程是必要的？

  1. 使用线程能够把占据长时间的程序中的任务放到后台去处理
  2. 用户界面能够更加吸引人，这样好比用户点击了一个按钮去触发某些事件的处理，能够弹出一个进度条来显示处理的进度
  3. 程序的运行速度可能加快

二 使用多线程

2.1继承Thread类

MyThread.java

public class MyThread extends Thread {
	@Override
	public void run() {
		super.run();
		System.out.println("MyThread");
	}
}
复制代码

Run.java

public class Run {

	public static void main(String[] args) {
		MyThread mythread = new MyThread();
		mythread.start();
		System.out.println("运行结束");
	}

}

复制代码

运行结果：

结果
从上面的运行结果能够看出： 线程是一个子任务，CPU以不肯定的方式，或者说是以随机的时间来调用线程中的run方法。

2.2实现Runnable接口

推荐实现Runnable接口方式开发多线程，由于Java单继承可是能够实现多个接口。

MyRunnable.java

public class MyRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println("MyRunnable");
	}
}
复制代码

Run.java

public class Run {

	public static void main(String[] args) {
		Runnable runnable=new MyRunnable();
		Thread thread=new Thread(runnable);
		thread.start();
		System.out.println("运行结束！");
	}

}
复制代码

运行结果：

运行结果

三 实例变量和线程安全

定义线程类中的实例变量针对其余线程能够有共享和不共享之分

3.1 不共享数据的状况

MyThread.java

public class MyThread extends Thread {

	private int count = 5;

	public MyThread(String name) {
		super();
		this.setName(name);
	}

	@Override
	public void run() {
		super.run();
		while (count > 0) {
			count--;
			System.out.println("由 " + MyThread.currentThread().getName()
					+ " 计算，count=" + count);
		}
	}
}
复制代码

Run.java

public class Run {
	public static void main(String[] args) {
		MyThread a = new MyThread("A");
		MyThread b = new MyThread("B");
		MyThread c = new MyThread("C");
		a.start();
		b.start();
		c.start();
	}
}

复制代码

运行结果：

运行结果
能够看出每一个线程都有一个属于本身的实例变量count，它们之间互不影响。咱们再来看看另外一种状况。

3.2 共享数据的状况

MyThread.java

public class MyThread extends Thread {

	private int count = 5;

	@Override
	 public void run() {
		super.run();
		count--;
		System.out.println("由 " + MyThread.currentThread().getName() + " 计算，count=" + count);
	}
}
复制代码

Run.java

public class Run {
	public static void main(String[] args) {
		
		MyThread mythread=new MyThread();
        //下列线程都是经过mythread对象建立的
		Thread a=new Thread(mythread,"A");
		Thread b=new Thread(mythread,"B");
		Thread c=new Thread(mythread,"C");
		Thread d=new Thread(mythread,"D");
		Thread e=new Thread(mythread,"E");
		a.start();
		b.start();
		c.start();
		d.start();
		e.start();
	}
}
复制代码

运行结果：

运行结果
能够看出这里已经出现了错误，咱们想要的是依次递减的结果。 为何呢？？

由于在大多数jvm中，count--的操做分为以下下三步：

  1. 取得原有count值
  2. 计算i -1
  3. 对i进行赋值

因此多个线程同时访问时出现问题就是难以免的了。

那么有没有什么解决办法呢？

答案是：固然有，并且很简单。

在run方法前加上synchronized关键字便可获得正确答案。

加上关键字后的运行结果：

加上关键字后的运行结果

四 一些经常使用方法

4.1 currentThread()

返回对当前正在执行的线程对象的引用。

4.2 getId()

返回此线程的标识符

4.3 getName()

返回此线程的名称

4.4 getPriority()

返回此线程的优先级

4.5 isAlive()

测试这个线程是否还处于活动状态。

什么是活动状态呢？

活动状态就是线程已经启动且还没有终止。线程处于正在运行或准备运行的状态。

4.6 sleep(long millis)

使当前正在执行的线程以指定的毫秒数“休眠”（暂时中止执行），具体取决于系统定时器和调度程序的精度和准确性。

4.7 interrupt()

中断这个线程。

4.8 interrupted() 和isInterrupted()

interrupted()：测试当前线程是否已是中断状态，执行后具备将状态标志清除为false的功能

isInterrupted()： 测试线程Thread对相关是否已是中断状态，但部清楚状态标志

4.9 setName(String name)

将此线程的名称更改成等于参数 name 。

4.10 isDaemon()

测试这个线程是不是守护线程。

4.11 setDaemon(boolean on)

将此线程标记为 daemon线程或用户线程。

4.12 join()

在不少状况下，主线程生成并起动了子线程，若是子线程里要进行大量的耗时的运算，主线程每每将于子线程以前结束，可是若是主线程处理完其余的事务后，须要用到子线程的处理结果，也就是主线程须要等待子线程执行完成以后再结束，这个时候就要用到join()方法了。

join()的做用是：“等待该线程终止”，这里须要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行

4.13 yield()

yield()方法的做用是放弃当前的CPU资源，将它让给其余的任务去占用CPU时间。注意：放弃的时间不肯定，可能一会就会从新得到CPU时间片。

4.14 setPriority(int newPriority)

更改此线程的优先级

五 如何中止一个线程呢？

stop(),suspend(),resume()（仅用于与suspend()一块儿使用）这些方法已被弃用，因此我这里不予讲解。

5.1 使用interrupt()方法

咱们上面提到了interrupt()方法，先来试一下interrupt()方法能不能中止线程 MyThread.java

public class MyThread extends Thread {
	@Override
	public void run() {
		super.run();
		for (int i = 0; i < 5000000; i++) {
			System.out.println("i=" + (i + 1));
		}
	}
}
复制代码

Run.java

public class Run {

	public static void main(String[] args) {
		try {
			MyThread thread = new MyThread();
			thread.start();
			Thread.sleep(2000);
			thread.interrupt();
		} catch (InterruptedException e) {
			System.out.println("main catch");
			e.printStackTrace();
		}
	}

}
复制代码

运行上诉代码你会发现，线程并不会终止。

针对上面代码的一个改进：

interrupted()方法判断线程是否中止，若是是中止状态则break

MyThread.java

public class MyThread extends Thread {
	@Override
	public void run() {
		super.run();
		for (int i = 0; i < 500000; i++) {
			if (this.interrupted()) {
				System.out.println("已是中止状态了!我要退出了!");
				break;
			}
			System.out.println("i=" + (i + 1));
		}
		System.out.println("看到这句话说明线程并未终止------");
	}
}
复制代码

Run.java

public class Run {

	public static void main(String[] args) {
		try {
			MyThread thread = new MyThread();
			thread.start();
			Thread.sleep(2000);
			thread.interrupt();
		} catch (InterruptedException e) {
			System.out.println("main catch");
			e.printStackTrace();
		}
		System.out.println("end!");
	}

}
复制代码

运行结果：

运行结果
for循环虽然中止执行了，可是for循环下面的语句仍是会执行，说明线程并未被中止。

5.2 使用return中止线程

MyThread.java

public class MyThread extends Thread {

	@Override
	public void run() {
			while (true) {
				if (this.isInterrupted()) {
					System.out.println("ֹͣ中止了!");
					return;
				}
				System.out.println("timer=" + System.currentTimeMillis());
			}
	}

}
复制代码

Run.java

public class Run {

	public static void main(String[] args) throws InterruptedException {
		MyThread t=new MyThread();
		t.start();
		Thread.sleep(2000);
		t.interrupt();
	}

}

复制代码

运行结果：

运行结果
固然还有其余中止线程的方法，后面再作介绍。

六 线程的优先级

每一个线程都具备各自的优先级，线程的优先级能够在程序中代表该线程的重要性，若是有不少线程处于就绪状态，系统会根据优先级来决定首先使哪一个线程进入运行状态。但这个并不意味着低 优先级的线程得不到运行，而只是它运行的概率比较小，如垃圾回收机制线程的优先级就比较低。因此不少垃圾得不到及时的回收处理。

线程优先级具备继承特性好比A线程启动B线程，则B线程的优先级和A是同样的。

线程优先级具备随机性也就是说线程优先级高的不必定每一次都先执行完。

Thread类中包含的成员变量表明了线程的某些优先级。如Thread.MIN_PRIORITY（常数1），Thread.NORM_PRIORITY（常数5）, Thread.MAX_PRIORITY（常数10）。其中每一个线程的优先级都在Thread.MIN_PRIORITY（常数1） 到Thread.MAX_PRIORITY（常数10） 之间，在默认状况下优先级都是Thread.NORM_PRIORITY（常数5）。

学过操做系统这门课程的话，咱们能够发现多线程优先级或多或少借鉴了操做系统对进程的管理。

线程优先级具备继承特性测试代码：

MyThread1.java：

public class MyThread1 extends Thread {
	@Override
	public void run() {
		System.out.println("MyThread1 run priority=" + this.getPriority());
		MyThread2 thread2 = new MyThread2();
		thread2.start();
	}
}

复制代码

MyThread2.java：

public class MyThread2 extends Thread {
	@Override
	public void run() {
		System.out.println("MyThread2 run priority=" + this.getPriority());
	}
}
复制代码

Run.java：

public class Run {
	public static void main(String[] args) {
		System.out.println("main thread begin priority="
				+ Thread.currentThread().getPriority());
		Thread.currentThread().setPriority(6);
		System.out.println("main thread end priority="
				+ Thread.currentThread().getPriority());
		MyThread1 thread1 = new MyThread1();
		thread1.start();
	}
}

复制代码

运行结果：

运行结果

七 Java多线程分类

7.1 多线程分类

用户线程：运行在前台，执行具体的任务，如程序的主线程、链接网络的子线程等都是用户线程

守护线程：运行在后台，为其余前台线程服务.也能够说守护线程是JVM中非守护线程的 “佣人”。

特色：一旦全部用户线程都结束运行，守护线程会随JVM一块儿结束工做

应用：数据库链接池中的检测线程，JVM虚拟机启动后的检测线程

最多见的守护线程：垃圾回收线程

7.2 如何设置守护线程？

能够经过调用Thead类的setDaemon(true)方法设置当前的线程为守护线程

注意事项：

1.  setDaemon(true)必须在start（）方法前执行，不然会抛出IllegalThreadStateException异常
2. 在守护线程中产生的新线程也是守护线程
3. 不是全部的任务均可以分配给守护线程来执行，好比读写操做或者计算逻辑
复制代码

MyThread.java：

public class MyThread extends Thread {
	private int i = 0;

	@Override
	public void run() {
		try {
			while (true) {
				i++;
				System.out.println("i=" + (i));
				Thread.sleep(100);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
复制代码

Run.java：

public class Run {
	public static void main(String[] args) {
		try {
			MyThread thread = new MyThread();
			thread.setDaemon(true);
			thread.start();
			Thread.sleep(5000);
			System.out.println("我离开thread对象也再也不打印了，也就是中止了！");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
复制代码

运行结果：

守护线程

若是你以为博主的文章不错，欢迎转发点赞。你能从中学到知识就是我最大的幸运。 欢迎关注个人微信公众号：“Java面试通关手册”（分享各类Java学习资源，面试题，以及企业级Java实战项目回复关键字免费领取）：

微信公众号
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程