文章目录
- 程序进程、线程的概念
- 单核与多核CPU的任务执行 并行与并发
- 多线程的优点
- 创建多线程方式1-继承Thread类
- 创建过程中的两个问题
- 创建多线程的一个练习
- 线程的常用方法
- 线程优先级的设置
- 创建多线程方式2-实现Runnable接口
- 两种创建方式的对比
- 线程的生命周期
- 线程的安全问题
- 线程安全问题的举例和解决措施
- 同步代码块处理实现Runnable的线程安全问题
- 同步代码块处理继承Thread类的线程安全问题
- 同步方法处理实现Runnable的线程安全问题
- 同步方法处理继承Thread类的线程安全问题
- 死锁问题
- Lock锁方式解决线程安全问题
- 线程的通信
- sleep()和wait()的异同
- 创建多线程的方式三:实现Callable接口
- 使用线程池的好处
程序进程、线程的概念
-
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一
段静态的代码,静态对象。
-
进程(process)是程序的一次执行过程,或是正在运行的一个程序。是一个动态
的过程:有它自身的产生、存在和消亡的过程。——生命周期
- 如:运行中的QQ,运行中的MP3播放器
- 程序是静态的,进程是动态的
- 进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域
-
线程(thread),进程可进一步细化为线程,是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多个线程,就是支持多线程的
- 线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小
- 一个进程中的多个线程共享相同的内存单元/内存地址空间(堆和方法区中)->它们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
单核与多核CPU的任务执行 并行与并发
-
单核CPU和多核CPU的理解
-
单核CPU,其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程的任务。例如:虽然有多车道,但是收费站只有一个工作人员在收费,只有收了费才能通过,那么CPU就好比收费人员。如果有某个人不想交钱,那么收费人员可以把他“挂起”(晾着他,等他想通了,准备好了钱,再去收费)。但是因为CPU时间单元特别短,因此感觉不出来。
-
如果是多核的话,才能更好的发挥多线程的效率。(现在的服务器都是多核的)
-
一个Java应用程序java.exe,其实至少有三个线程:main()主线程,gc()
-
垃圾回收线程,异常处理线程。当然如果发生异常,会影响主线程。
-
-
并行与并发
- **并行:**多个CPU同时执行多个任务。比如:多个人同时做不同的事。
- **并发:**一个CPU(采用时间片)"同时"执行多个任务。比如:秒杀、多个人做同一件事。
多线程的优点
**背景:**以单核CPU为例,只使用单个线程先后完成多个任务(调用多个方
法),肯定比用多个线程来完成用的时间更短,为何仍需多线程呢?
- 多线程程序的优点:
-
提高应用程序的响应。对图形化界面更有意义,可增强用户体验。
-
提高计算机系统CPU的利用率
-
改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和
修改
-
何时需要多线程:
-
程序需要同时执行两个或多个任务。
-
程序需要实现一些需要等待的任务时,如用户输入、文件读写
操作、网络操作、搜索等。
- 需要一些后台运行的程序时。
-
创建多线程方式1-继承Thread类
-
线程的创建和启动
-
Java语言的JVM允许程序运行多个线程,它通过java.lang.Thread
类来体现。
-
Thread类的特性
-
每个线程都是通过某个特定Thread对象的run()方法来完成操作的,经常
把run()方法的主体称为线程体
-
通过该Thread对象的start()方法来启动这个线程,而非直接调用run()
-
-
/**
* 多线程的创建:
* 方式一:继承Thread类
* 1.创建一个继承于Thread类的子类
* 2.重写Thread类中的run()方法 -->将此线程执行的操作声明在run()中
* 3.创建Thread类的子类的对象
* 4.通过此对象调用start()
* 例子:遍历100内所有的偶数
*/
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) throws InterruptedException {
MyThread myThread1 = new MyThread();
myThread1.start();
//验证多线程
for (int i = 0; i < 100; i++) {
System.out.println("*********main()**********");
}
}
}
创建过程中的两个问题
class MyThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) throws InterruptedException {
MyThread myThread1 = new MyThread();
//start():①启动当前线程 ②调用当前线程的run()
myThread1.start();
//myThread1.run();
//问题1:不能通过直接调用run()方法的方式启动线程,否则仅仅会存在main线程,并不会启动另一个线程
//问题2:再启动一个线程,遍历100以内的偶数;不可以让已经start的线程去执行,会报IllegalThreadStateException
//需要重新创建一个线程的对象
//myThread1.start();
MyThread myThread2 = new MyThread();
myThread2.start();
//如下操作仍然是在main线程执行
for (int i = 0; i < 100; i++) {
System.out.println("*********main()**********");
}
}
}
创建多线程的一个练习
public class ThreadDemo {
public static void main(String[] args) {
// MyThread1 mt1 = new MyThread1();
// MyThread2 mt2 = new MyThread2();
// mt1.start();
// mt2.start();
//MyThread1和MyThread2的具体实现略
//方式二:创建Thread类的匿名子类
new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
new Thread() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
}
}
线程的常用方法
-
void start(): 启动线程,并执行对象的run()方法
-
run(): 线程在被调度时执行的操作,通常需要重写
-
String getName(): 返回当前线程的名称
-
void setName(String name):设置该线程名称
-
static Thread currentThread(): 返回执行当前代码的线程。在Thread子类中就
是this,通常用于主线程和Runnable实现类
-
static void yield():线程让步
-
释放当前CPU的执行权,暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程
-
若队列中没有同优先级的线程,忽略此方法
-
join() **:**当在线程a中调用线程b的join(),线程a将
进入阻塞状态,直到 join() 方法加入的b线程执行完为止
- 低优先级的线程也可以获得执行
-
-
static void sleep(long millis):(指定时间:毫秒)
- 令当前活动线程在指定时间段内放弃对CPU控制,为阻塞状态,使其他线程有机会被执行,时间到后重新排队。
- 抛出InterruptedException异常
-
stop(): 强制线程生命期结束,不推荐使用(已过时)
-
boolean isAlive():返回boolean,判断线程是否还活着
class HelloThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
try {//不能throws,因为Thread类中的run()没有抛异常 子类不能抛出比父类更宽泛的异常
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+i);
}
if (i%20==0){
yield();
}
}
}
public HelloThread(String name){
super(name);
}
}
public class ThreadMethodTest {
public static void main(String[] args) throws InterruptedException {
HelloThread helloThread = new HelloThread("Thread1");
// helloThread.setName("别做舔狗Thread");
helloThread.start();
//给主线程命名
Thread.currentThread().setName("主线程");
for (int i = 0; i < 100; i++) {
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
if (i==19){
helloThread.join();
}
}
System.out.println(helloThread.isAlive());
}
}
线程优先级的设置
-
线程的优先级
class HelloThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
}
if (i%20==0){
yield();
}
}
}
public HelloThread(String name){
super(name);
}
}
public class ThreadMethodTest {
public static void main(String[] args) throws InterruptedException {
HelloThread helloThread = new HelloThread("Thread1");
//设置分线程的优先级
helloThread.setPriority(Thread.MAX_PRIORITY);
helloThread.start();
//给主线程命名
Thread.currentThread().setName("主线程");
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
for (int i = 0; i < 100; i++) {
if (i%2!=0){
System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
}
if (i==19){
helloThread.join();
}
}
}
}
创建多线程方式2-实现Runnable接口
/**
* 创建多线程的方式二:实现Runnable接口
* 1.创建一个实现了Runnable接口的实现类
* 2.实现类中去实现Runnable中的抽象方法run()
* 3.创建实现类的对象
* 4.将此对象传到Thread类的构造器中,创建Thread类的对象
* 5.通过Thread类的对象调用start()
*/
class MThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2==0){
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
}
}
public class RunnableTest {
public static void main(String[] args) {
MThread mThread = new MThread();
Thread thread = new Thread(mThread);
//start():①启动当前线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
thread.start();
//再启动一个线程,遍历100以内的偶数 不需要再new一个Runnable的实现类
Thread thread1 = new Thread(mThread);
thread1.start();
}
}
两种创建方式的对比
-
开发中优先选择实现Runnable接口的方式
- 实现的方式没有类的单继承的局限性
- 实现的方式更适合处理多个线程有共享数据的情况
-
联系:Thread类本身也实现了Runnbale接口
-
相同点:不管是继承还是实现的方式,两种方式都需要重写run()方法,将线程要执行的逻辑声明在run()中
线程的生命周期
线程的安全问题
线程访问共享数据时会出现安全问题
线程安全问题的举例和解决措施
-
卖票过程中出现了错票和重票–>出现了线程安全问题
-
出现原因:当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票。
-
如何解决:当一个线程a在操作车票(共享数据)时,其他线程不能参与进来,直到线程a操作完时其他线程才可以操作。这种情况下即使线程a出现了阻塞也不能被改变。
同步代码块处理实现Runnable的线程安全问题
-
在Java中,通过同步机制解决线程安全问题
-
方式1:同步代码块
synchronized(同步监视器){ //需要被同步的代码 }
说明:操作共享数据的代码,即为需要被同步的代码–>不能包多了也不能包少了
共享数据:多个线程共同操作的变量。
同步监视器:俗称锁。任何一个类的对象都可以充当锁
要求:多个线程必须要共用一把锁
在实现Runnable接口创建多线程的方式中,可以考虑使用this充当同步监视器
在继承Thread类创建多线程的方式中,慎用this!可以考虑使用当前类来充当同步监视器
-
方式2:同步方法
-
-
同步的方式,解决了线程的安全问题,但是操作同步代码时,只能有一个线程参与,其他线程等待。相当于是一个单线程的过程,效率低。
class Window implements Runnable{
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true){
synchronized(obj){
if (ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+ticket);
ticket--;
}else{
break;
}
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window w = new Window();
Thread thread1 = new Thread(w);
Thread thread2 = new Thread(w);
Thread thread3 = new Thread(w);
thread1.setName("窗口1");
thread2.setName("窗口2");
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
同步代码块处理继承Thread类的线程安全问题
class Window2 extends Thread{
private static int ticket = 100;
static Object obj = new Object();
@Override
public void run() {
while (true){
//synchronized(obj){
synchronized(Window2.class){//Class clazz = Window2.class
//错误的方式:this代表着t1,t2,t3三个对象
//synchronized(this){
if (ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+ticket);
ticket--;
}else{
break;
}
}
}
}
}
public class WindowTest2 {
public static void main(String[] args) {
Window2 t1 = new Window2();
Window2 t2 = new Window2();
Window2 t3 = new Window2();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
同步方法处理实现Runnable的线程安全问题
- 同步方法:如果操作共享数据的代码完整声明在一个方法中,我们不妨将这个方法声明同步
class Window3 extends Thread{
private static int ticket = 100;
static Object obj = new Object();
@Override
public void run() {
while (true){
show();
}
}
private synchronized void show(){//同步监视器为this
if (ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+ticket);
ticket--;
}
}
}
public class WindowTest3 {
public static void main(String[] args) {
Window3 w = new Window3();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
同步方法处理继承Thread类的线程安全问题
class Window4 extends Thread{
private static int ticket = 100;
static Object obj = new Object();
@Override
public void run() {
while (true){
show();
}
}
private static synchronized void show(){//同步监视器:Window4.class
//private synchronized void show(){//同步监视器this:t1,t2,t3 此种方法是错误的
if (ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+ticket);
ticket--;
}
}
}
public class WindowTest4 {
public static void main(String[] args) {
Window4 t1 = new Window4();
Window4 t2 = new Window4();
Window4 t3 = new Window4();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
总结:1.同步方法仍然涉及到同步监视器,只是不需要显式声明
2.非静态的同步方法,同步监视器是this
3.静态的同步方法,同步监视器是当前类本身
死锁问题
- 死锁的理解:不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
- 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
- 解决方法:
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
public class ThreadTest {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
Thread thread = new Thread() {
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
};
thread.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2){
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
Lock锁方式解决线程安全问题
解决线程安全问题的方式三:Lock锁 -----JDK5.0新增的方式
-
synchronized方式和Lock的异同
-
相同:都可以解决线程安全问题
-
不同:synchronized机制在执行完相应的同步代码以后,自动释放同步监视器;
Lock需要手动启动同步(lock()),同时结束同步也需要手动实现(unlock())
-
线程的通信
/**
* 使用两个线程打印 1-100。线程1, 线程2 交替打印
*
* 涉及到的三个方法:
* wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器
* notify():一旦执行此方法,就会唤醒wait的一个线程,如果有多个线程被wait,就唤醒优先级最高的那个
* notifyAll():一旦执行此方法,就会唤醒所有被wait的线程
*
* 说明:
* 1.wait() notify() notifyAll()必须使用在同步代码块或同步方法中!
* 2.wait() notify() notifyAll()的调用者必须是同步代码块或同步方法中的同步监视器!
* 否则会出现异常
* 3.wait() notify() notifyAll()三个方法定义在java.lang.Object类中
*/
class Number implements Runnable{
private int number = 1;
@Override
public void run() {
while (true){
synchronized (this){
notify();
//notifyAll();
if (number<=100){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+number);
number++;
try {
//使得调用如下wait()方法的线程进入阻塞状态
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
break;
}
}
}
}
}
public class NumberCommunication {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
sleep()和wait()的异同
- 相同点
- 一旦执行方法,都可以使得当前线程进入阻塞状态
- 不同点
- 声明的位置不同:Thread类中声明sleep(),Object类中声明wait()
- 调用的要求不同:sleep()可以在任何需要的场景下调用,wait()必须在同步代码块或同步方法中调用
- 关于是否释放同步监视器的问题:如果两个方法都在同步代码块或同步方法中调用,sleep()不会释放锁,wait()会释放锁
创建多线程的方式三:实现Callable接口
----JDK5.0新增
-
步骤
- 创建一个实现Callable接口的实现类
- 实现call方法,将此线程需要执行的操作声明在call方法中
- 创建Callable接口实现类的对象
- 将此Callable实现类对象作为参数传递到FutureTask的构造器中,创建FutureTask的对象
- 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象并start()
- (可选)获取Callable中call方法的返回值
-
实现Callable接口的方式创建多线程比实现Runnable接口创建多线程强大
- call()方法可以有返回值
- call()方法可以抛出异常,被外面的操作捕获,获取异常的信息
- Callable是支持泛型的
package threadTest;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class NumThread implements Callable{
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i < 100; i++) {
if (i%2==0){
sum+=i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args) {
NumThread numThread = new NumThread();
FutureTask futureTask = new FutureTask(numThread);
//new Thread(futureTask).start();
try {
//get()方法的返回值即为futureTask构造器参数Callable实现类对象重写的call()方法的返回值
Object sum = futureTask.get();
System.out.println(sum);
System.out.println(Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
使用线程池的好处
线程池后续补充…