文章目录
程序,进程,线程的基本概念
- 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象。
- 进程(process)是程序的一次执行代码,或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期
- 如:运行中的QQ
- 程序是静态的,进程是动态的
- 进程作为资源分配的单位,系统在运行时会为每个进程分配不同的区域
- 线程(thread),进程可进一步细化为线程,是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多个线程,就是支持多线程的
- 线程作为调度和执行单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小。
- 一个进程中的多个线程共享相同的内存单元/内存地址空间->同门从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
- 并行和并发:
并行:多个CPU同时执行多个任务。比如多个人同时做不同的事。
并发:一个CPU同时执行多个任务。
多线程的优点
- 提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改
为什么需要多线程
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
创建一个多线程
方式一:继承Thread
- 创建一个继承于Thread类的子类
- 重写Thread类的run()–>将此线程执行的操作声明在run()中
- 创建Thread类的子类对象
- 调用此对象start()
start方法的作用:
1)启动一个线程;
2)调用此线程的run方法
class TreadTest{
static class Tread_1 extends Thread{
public void run(){
for(int i = 0;i<10000;i++){
if(i%2==0)
System.out.println(Thread.currentThread().getName()+factorial(i));
}
}
}
public static void main(String[] args){
// int i = 10;
// System.out.println(factorial(i));
Tread_1 thread = new Tread_1();
thread.start(); // start方法的作用:1.启动一个线程;2.调用此线程的run方法
for(int i=0;i<10000;i++){
if(i%2==0)
System.out.println(Thread.currentThread().getName()+factorial(i));
}
new Thread(){public void run(){
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}}.start(); //匿名对象
}
static int factorial(int i){
if(i<=1)
{return 1;}
else
{return i*factorial(i-1);}
}
}
方式二:实现Runable接口
- 创建一个实现了Runable接口的类
- 实现类去实现Runable中的抽象方法:run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
- 通过Thread类的对象调用start()
RunThread thread1 = new RunThread();
new Thread(thread1,"thread1").start(); // 调用线程
class RunThread implements Runnable{
public int x=1000;
public void run(){
// for(int i=0;i<3000;i++){
// if(x>=0){
// System.out.println(Thread.currentThread().getName()+" "+ x--);
//
// }
// }
while(x>0){
System.out.println(Thread.currentThread().getName()+" "+ x--);
}
}
}
两种方式对比
开发中:优先选择,实现Runable接口的方法
原因:1.)实现的方法不会存在 类的单继承的局限性。2)实现的方式更适合来处理多个线程共享数据的情况
两种方式的相同点:两种方式都要重写run(),将线程要执行的逻辑声明在run()中。目前的两种方式,要想启动线程,都是调用Thread类中的start()
新增方式一:实现Callable接口
-
相比run()方法,可以有返回值
-
方法可以抛出异常
-
支持泛型的返回值
-
需要借助FutureTask类,比如获取返回结果
Future接口
- 可以对具体Runable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutureTask是Future接口的唯一的实现类
- FutureTask同时实现了Runnable,Future接口,它既可以作为Runable被线程执行,又可以作为Futurede得到Callable的返回值。
代码示例:
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* 创建线程的方式三:实现Callable接口。 --- JDK 5.0新增
*
*
* 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
* 1. call()可以有返回值的。
* 2. call()可以抛出异常,被外面的操作捕获,获取异常的信息
* 3. Callable是支持泛型的
*
* @author shkstart
* @create 2019-02-15 下午 6:01
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法,将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i <= 100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread = new NumThread();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
Object sum = futureTask.get();
System.out.println("总和为:" + sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
新增方式二:使用线程池
为什么使用线程池创建线程?
-
背景:经常创建和销毁、使用量特别大的资源,比如并发下的线程,对性能影响很大。
-
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的接通工具
-
好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中的线程,不需要每次都创建)
- 便于线程管理
- corePoolSize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后静止。
如何创建线程池
package com.atguigu.interview;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//创建并使用多线程的第四种方法:使用线程池
class MyThread implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public class ThreadPool {
public static void main(String[] args) {
// 1.调用Executors的newFixedThreadPool(),返回指定线程数量的ExecutorService
ExecutorService pool = Executors.newFixedThreadPool(10);
// 2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中,开启线程
// 并执行相关的run()
pool.execute(new MyThread());
pool.execute(new MyThread());
pool.execute(new MyThread());
// 3.结束线程的使用
pool.shutdown();
}
}
测试Thread中的常用方法
- start():启动当前线程;调用当前线程的run()
- run():Tsingtao需要重写Thread中的方法,创建线程的操作需要写在这里。
- currentTread():静态方法,返回执行当前代码的线程(应该是地址)
- getName():获取当前线程的名字
- setName():设置当前线程的名字
- yield(): 线程执行此方法时,释放当前cpu的执行权
- join(): thread1.join(),在某个线程中调用另外一个线程中的join方法,此时某线程处于阻塞状态,则开始执行这个线程直到执行完毕,接下来继续执行某线程。
- stop():(已过时)强制线程生命周期结束。
- sleep(long millitime):线程休眠一段时间。指定的时间内,当前线程是阻塞状态。
- isAlive():判断某个线程是否在执行
线程的优先级
线程优先级的数值只是概率,并不是优先级数值越大执行优先级就一定高,也不是说高优先级的线程执行完低优先级的线程才会执行。
- 相关常量
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5 - 如何获取当前线程的优先级
- getPriority(): 获取线程的优先级
- setPriority(int p) :设置线程的优先级
线程通信
wait()/ notify()/ notifyAll():此三个方法定义在Object类中
线程的分类:
java线程分为两类:一种是守护线程,一种是用户线程。
- 它们在几乎每个方面都是相同的,唯一的区别是判断JVM何时离开。
- 守护线程是用来服务用户线程的,通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成守护线程。
- java垃圾回收就是一个典型的守护线程。
- 若JVM中都是守护线程,当前JVM将推出
线程的生命周期:
线程的同步
方式一:synchronized同步代码块
synchronized(同步监视器){
需要同步的代码
}
- 操作共享数据的代码,即为需要被同步的代码。
- 共享数据:多个新城共同操作的变量
- 同步监视器:俗称,锁。任何一个类的对象,都可以充当锁。要求:多个线程必须共用一把锁。
补充:在实现Runable接口创建的多线程方式中,我们可以考虑使用this充当同步监视器。(因为用Runable接口实现的方式,多个线程一般共用此类,所以this为同一个this)
class Singleton{
private Singleton(){}
private static Singleton instan = null;
// 同步代码块的方式实施线程安全
public static Singleton getInstance() {
synchronized (Singleton.class) {
if (instan == null) {
return new Singleton();
}
return instan;
}
}
}
方式二:synchronized同步方法
如果操作共享数据的代码完整的声明在一个车方法中,我们可以将此方法声明为同步的。
class Singleton{
private Singleton(){}
private static Singleton instan = null;
// 同步方法的方式实施线程安全
public static synchronized Singleton getInstance(){
if (instan == null){
return new Singleton();
}else{
return instan;
}
}
}
同步方式的优缺点
优势:解决了线程安全的问题
劣势:操作同步代码时,只能有一个线程参与,其他线程等待,相当于是一个单线程的过程,效率低。
关于同步的总结
- 同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。
- 非静态的同步方法,同步监视器是:this
- 静态的同步方法,同步监视器是:当前类本身
释放安全锁和不释放安全锁的操作:
释放安全锁的操作:
不释放安全锁的操作:
死锁的问题
- 死锁的理解:不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
- 说明:
- 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
- 我们使用同步时,要避免出现死锁
死锁代码示例:
package dead_lock;
class A {
public synchronized void foo(B b) { // 同步监视器(锁)是对象A
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 进入了A实例的foo方法"); // ①
try {
Thread.sleep(200);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 企图调用B实例的last方法"); // ③
b.last(); // 需要先有A然后有B的锁才能运行,运行完才能释放A的锁
}
public synchronized void last() { // 同步监视器(锁):对象A
System.out.println("进入了A类的last方法内部");
}
}
class B {
public synchronized void bar(A a) { // 同步监视器(锁):对象B
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 进入了B实例的bar方法"); // ②
try {
Thread.sleep(200);
} catch (InterruptedException ex) {
ex.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName()
+ " 企图调用A实例的last方法"); // ④
a.last();
}
public synchronized void last() { // 同步监视器(锁):对象B
System.out.println("进入了B类的last方法内部");
}
}
public class DeadLock implements Runnable {
A a = new A();
B b = new B();
public void init() {
Thread.currentThread().setName("主线程");
// 调用a对象的foo方法
a.foo(b);
System.out.println("进入了主线程之后");
}
public void run() {
Thread.currentThread().setName("副线程");
// 调用b对象的bar方法
b.bar(a);
System.out.println("进入了副线程之后");
}
public static void main(String[] args) {
DeadLock dl = new DeadLock();
new Thread(dl).start(); // 线程一:运行run()方法
dl.init(); // 主线程:运行init()方法
}
}
通过Lock锁来解决线程安全问题
ReentrantLock lock = new ReentrantLock()
lock.lock();
// 同步代码
lock.unlock();
snchronized和Lock的异同?
- 相同:二者都可以解决线程安全问题
- 不同:synchronized机制在执行完相应的同步代码以后,自动释放同步监视器,Lock需要手动的启动同步(Lock()),同时结束同步也需要手动实现(unlock())。
线程的通信:
- wait():一旦执行此方法,当前线程就进入阻塞状态,并释放多个监视器。
- notify():一旦执行此方法,就会唤醒被- wait()的一个线程。如果有多个线程被wait,就唤醒优先级高的
- notifyAll():一旦执行此方法,就会唤醒所有被wait的线程
注意:
- wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
- wait(),notify(),notifyAll()三个方法的调用者必须是
同步代码块或同步方法
中的同步监视器。否则会报IllegalMonitorStateException异常。
sleep()和wait()方法的异同?
- 相同点,一旦执行方法,都可以使得当前线程进入阻塞状态
- 不同点:
1)两个方法声明的位置不同:Thread类中声明sleep(),object类中声明wait()
2)调用的要求不同:sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中。
3)如果两个方法都是用在同步代码块或同步方法中,sleep()不会释放同步监视器,wait()会释放同步监视器。