一步一步学JAVA(12)-多线程

最新推荐文章于 2022-12-26 15:48:49 发布

原创最新推荐文章于 2022-12-26 15:48:49 发布 · 169 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多线程 #synchronized #Runnable

java笔记专栏收录该内容

19 篇文章

订阅专栏

本文详细解析了进程与线程的概念，介绍了Java中创建多线程的两种方式，包括继承Thread类和实现Runnable接口，以及多线程的安全问题和解决方案。

多线程

进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。
线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。
一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。
jvm 在启动的时，首先有一个主线程，负责程序的执行，调用的是main 函数。主线程执行的代码都在main 方法中。
当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。
随机性的原理：因为cpu 的快速切换造成，哪个线程获取到了cpu 的执行权，哪个线程就执行。
返回当前线程的名称：Thread.currentThread().getName()
线程的名称是由：Thread-编号定义的。编号从0 开始。
线程要运行的代码都统一存放在了run 方法中。
线程要运行必须要通过类中指定的方法开启。start 方法。（启动后，就多了一条执行路径）
start 方法：1）、启动了线程；2）、让jvm 调用了run 方法。
创建线程的第一种方式：继承Thread ，由子类复写run 方法。
步骤：

定义类继承Thread 类；
目的是复写run 方法，将要让线程运行的代码都存储到run 方法中；
通过创建Thread 类的子类对象，创建线程对象；
调用线程的start 方法，开启线程，并执行run 方法。

线程状态：
被创建：start()
运行：具备执行资格，同时具备执行权；
冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；
临时阻塞状态：线程具备cpu 的执行资格，没有cpu 的执行权；
消亡：stop()
创建线程的第二种方式：实现一个接口Runnable。
步骤：

定义类实现Runnable 接口。
覆盖接口中的run 方法（用于封装线程要运行的代码）。
通过Thread 类创建线程对象；
将实现了Runnable 接口的子类对象作为实际参数传递给Thread 类中的构造函数。为什么要传递呢？因为要让线程对象明确要运行的run 方法所属的对象。
调用Thread 对象的start 方法。开启线程，并运行Runnable 接口子类中的run 方法。

Ticket t = new Ticket();
/*
直接创建Ticket 对象，并不是创建线程对象。
因为创建对象只能通过new Thread 类，或者new Thread 类的子类才可以。
所以最终想要创建线程。既然没有了Thread 类的子类，就只能用Thread 类。
*/
Thread t1 = new Thread(t); //创建线程。
/*
只要将t 作为Thread 类的构造函数的实际参数传入即可完成线程对象和t 之间的关联,为什么要将t 传给Thread 类的构造函数呢？其实就是为了明确线程要运行的代码run 方法。
*/
t1.start();

为什么要有Runnable 接口的出现？
1：通过继承Thread 类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread 类，因为java 单继承的局限性。
可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？
只有对该类进行额外的功能扩展，java 就提供了一个接口Runnable。这个接口中定义了run 方法，其实run方法的定义就是为了存储多线程要运行的代码。
所以，通常创建线程都用第二种方式。
因为实现Runnable 接口可以避免单继承的局限性。
2：其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。
所以Thread 类在描述线程时，内部定义的run 方法，也来自于Runnable 接口。
实现Runnable 接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread 类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable 接口更方便一些。所以Runnable 接口将线程要执行的任务封装成了对象。
-------------------------------------------------------
//面试

new Thread(new Runnable(){ //匿名
    public void run(){
        System.out.println("runnable run");
       }
    })
{
    public void run(){
        System.out.println("subthread run");
    }
}.start(); //结果：subthread run

Try {
    Thread.sleep(10);
} catch(InterruptedException e){}// 当刻意让线程稍微停一下，模拟cpu 切换情况。

多线程安全问题的原因：
通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。
涉及到两个因素：
1，多个线程在操作共享数据。
2，有多条语句对共享数据进行运算。
原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。
解决安全问题的原理：
只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。
如何进行多句操作共享数据代码的封装呢？
java 中提供了一个解决方式：就是同步代码块。
格式：
synchronized(对象) { // 任意对象都可以。这个对象就是锁。
需要被同步的代码；
}

Lock 接口：多线程在JDK1.5 版本升级时，推出一个接口Lock 接口。
解决线程安全问题使用同步的形式，(同步代码块，要么同步函数)其实最终使用的都是锁机制。
到了后期版本，直接将锁封装成了对象。线程进入同步就是具备了锁，执行完，离开同步，就是释放了锁。
在后期对锁的分析过程中，发现，获取锁，或者释放锁的动作应该是锁这个事物更清楚。所以将这些动作定义在了锁当中，并把锁定义成对象。
所以同步是隐示的锁操作，而Lock 对象是显示的锁操作，它的出现就替代了同步。
在之前的版本中使用Object 类中wait、notify、notifyAll 的方式来完成的。那是因为同步中的锁是任意对象，所以操作锁的等待唤醒的方法都定义在Object 类中。
而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock 接口来完成。而Lock 接口中并没有直接操作等待唤醒的方法，而是将这些方式又单独封装到了一个对象中。这个对象就是Condition，将Object 中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。
< java.util.concurrent.locks > Condition 接口：await()、signal()、signalAll()；

package com.qzb.test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class BoundedBuffer {
	final Lock lock = new ReentrantLock();
	final Condition notFull = lock.newCondition();
	final Condition notEmpty = lock.newCondition();
	final Object[] items = new Object[100];
	int putptr, takeptr, count;

	public void put(Object x) throws InterruptedException {
		lock.lock();
		try {
			while (count == items.length)
				notFull.await();
			items[putptr] = x;
			if (++putptr == items.length)
				putptr = 0;
			++count;
			notEmpty.signal();
		} finally {
			lock.unlock();
		}
	}

	public Object take() throws InterruptedException {
		lock.lock();
		try {
			while (count == 0)
				notEmpty.await();
			Object x = items[takeptr];
			if (++takeptr == items.length)
				takeptr = 0;
			--count;
			notFull.signal();
			return x;
		} finally {
			lock.unlock();
		}
	}
}