Java多线程（一）

最新推荐文章于 2024-07-08 14:58:49 发布

m0_45198397

最新推荐文章于 2024-07-08 14:58:49 发布

阅读量158

点赞数

分类专栏： Java秋招之路文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/m0_45198397/article/details/128341511

版权

Java秋招之路专栏收录该内容

4 篇文章 1 订阅

订阅专栏

1 概念

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。（进程是资源分配的最小单位）。多进程是指操作系统能同时运行多个任务（程序）；

线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小（不一定）。（线程是cpu调度的最小单位）多线程是指在同一程序中有多个顺序流在执行。

线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。

多线程的好处:

线程比进程开销小，更容易创建和释放。
多个线程是IO密集型时，多线程可以使这些活动彼此重叠运行，可以加快程序执行的速度。

对于线程需要考虑：

线程之间有无先后访问顺序(线程依赖关系)
多个线程共享访问同一变量（同步互斥问题)
同一进程的多个线程共享进程的资源，除了标识线程的tid，每个线程还有自己独立的栈空间，线程彼此之间是无法访问其他线程栈上内容的。

2 Java中实现多线程的方式

在java中要想实现多线程，有两种手段，一种是继承Thread类，另外一种是实现Runable接口。(还有一种是实现Callable接口，并与Future、线程池结合使用，下次学习）

2.1 扩展java.lang.Thread类

class Thread1 extends Thread{
	private String name;
    public Thread1(String name) {
       this.name=name;
    }
	public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行  :  " + i);
            try {
                sleep((int) Math.random() * 10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
       
	}
}
public class Main {
 
	public static void main(String[] args) {
		Thread1 mTh1=new Thread1("A");
		Thread1 mTh2=new Thread1("B");
		mTh1.start();
		mTh2.start();
 
	}
 
}

运行结果：所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。

说明：程序启动运行main时候，java虚拟机启动一个进程，主线程main在main()调用时候被创建。随着调用MitiSay的两个对象的start方法，另外两个线程也启动了，这样，整个应用就在多线程下运行。注意：start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU资源，以留出一定时间给其他线程执行的机会。
实际上

2.2 实现java.lang.Runnable接口

package com.multithread.runnable;
class Thread2 implements Runnable{
	private String name;
 
	public Thread2(String name) {
		this.name=name;
	}
 
	@Override
	public void run() {
		  for (int i = 0; i < 5; i++) {
	            System.out.println(name + "运行  :  " + i);
	            try {
	            	Thread.sleep((int) Math.random() * 10);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
		
	}
	
}
public class Main {
 
	public static void main(String[] args) {
		new Thread(new Thread2("C")).start();
		new Thread(new Thread2("D")).start();
	}
 
}

说明：只需要重写run方法即可。Thread2类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是扩展Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

2.3 Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去处理同一个资源
可以避免java中的单继承的限制
增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

注意：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。

2.4 start()方法和run()方法的区别

start()：用Thread类的 start方法来启动线程，是真正实现了多线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法。但要注意的是，此时无需等待run()方法执行完毕，即可继续执行下面的代码。

run()：需要并行处理的代码放在run方法中，start方法启动线程后自动调用run方法。如果直接调用线程类的run()方法，这会被当做一个普通的函数调用，程序中仍然只有主线程这一个线程，程序还是要等待run方法体执行完毕后才可继续执行下面的代码，所以run()方法并没有实现多线程。

区别：

1、线程中的start()方法和run()方法的主要区别在于，当程序调用start()方法，将会创建一个新线程去执行run()方法中的代码。但是如果直接调用run()方法的话，会直接在当前线程中执行run()中的代码，不会创建新线程。
2、当一个线程启动之后，不能重复调用start()，否则会报IllegalStateException异常。但是可以重复调用run()方法。
3、start()方法能够异步地调用run()方法，真正实现了多线程；但是直接调用run()方法却是同步的，因此也就无法达到多线程的目的。

3 线程状态转换

3.1 常见状态简介【见图说话：

1、初始状态（New）：新创建了一个线程对象。
2、就绪（可运行）状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
（一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
（二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
（三）、其他阻塞：对应上图的阻塞状态。运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）
5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

3.2 常用函数说明

①sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

②join():指等待t线程终止。指的是主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了主线程才能继续执行。

③yield():“退让”。暂停当前正在执行的线程对象，并执行其他线程。Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。结论：yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

sleep()和yield()的区别

sleep()使当前线程进入阻塞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
sleep方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则，继续运行原来的线程。
sleep 方法允许较低优先级的线程获得运行机会，但 yield() 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

④setPriority(): 更改线程的优先级。
　　　MIN_PRIORITY = 1
　　 NORM_PRIORITY = 5
MAX_PRIORITY = 10

用法：

Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

⑤interrupt():线程发送一个中断信号，让线程在无限等待时（如死锁时）能抛出抛出，从而结束线程，但是如果对正常运行的线程发送，那么这个线程还是不会中断的。

⑥Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait和notify是对已经获取了Obj锁的对象进行操作，即Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。

功能：线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。

建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。

Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

wait和sleep区别

sleep（）方法：sleep()使当前线程进入停滞状态（阻塞当前线程），让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会;sleep()是Thread类的Static(静态)的方法；因此他不能改变对象的机锁，所以当在一个Synchronized块中调用Sleep()方法是，线程虽然休眠了，但是对象的机锁并没有被释放，其他线程无法访问这个对象（即使睡着也持有对象锁）。
wait（）方法：是Object类里的方法；当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去（释放）了对象的机锁（暂时失去机锁，wait(long timeout)超时时间到后还需要返还对象锁）；其他线程可以访问该锁；wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。wiat()必须放在synchronized block中，否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。
不同点：
1. sleep(),yield()等是Thread类的方法；而 wait()和notify()等是Object的方法。
2. 每个对象都有一个锁来控制同步访问。sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。

4 JAVA synchronized 同步机制

4.1 概念及特性

synchronized 是 Java 中的关键字，是利用锁的机制来实现同步的。

互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程中的协调机制，互斥性也往往称为操作的原子性。

可见性：必须确保在锁被释放之前，对共享变量所做的修改，对于随后获得该锁的另一个线程是可见的，即在获得锁时应获得最新共享变量的值。

4.2 对象锁和类锁

对象锁：在 Java 中，每个对象都会有一个 monitor 对象，这个对象其实就是 Java 对象的锁，通常会被称为“内置锁”或“对象锁”。可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。类的对象可以有多个，所以每个对象有其独立的对象锁，互不干扰（类的不同对象之间异步）。

类锁：在 Java 中，针对每个类也有一个锁，可以称为“类锁”，每个类只有一个 Class 对象，所以每个类只有一个类锁（类的各个对象之间同步）。

4.3 synchronized 的用法分类

从两个维度上面分类：

1. 根据修饰对象分类：synchronized 可以修饰方法和代码块

修饰代码块：synchronized(this|object) {} / synchronized(类.class) {}

修饰方法：修饰非静态方法 / 修饰静态方法

2. 根据获取的锁分类
获取对象锁：synchronized(this|object) {} / 修饰非静态方法。如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法。

获取类锁：synchronized(类.class) {} / 修饰静态方法

4.4 synchronized 的用法详解

用法详解，这篇讲得好！

4.5 synchronized总结+补充

线程同步方法是通过锁来实现，每个对象都有且仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他非同步方法；
对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
对于同步，要时刻清醒在哪个对象上同步，这是关键。
当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
死锁是线程间相互等待锁锁造成的，一旦程序发生死锁，程序将死掉。
synchronized关键字是不能继承的。也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；
在定义接口方法时不能使用synchronized关键字。
构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。
无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁；
实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

数据字典

数据字典是一种通用的程序设计方法。可以认为，不论什么程序，都是为了处理一定的主体，这里的主体可能是人员、商品(超子)、网页、接口等等。当主体有很多的属性，每种属性有很多的取值，而且属性的数量和属性取值的数量是不断变化的，特别是当这些数量的变化很快时，就应该考虑引入数据字典的设计方法。

例子：数据字典 - 百度文库 (baidu.com) 写了两种数据字典的方法

数据字典的优点/缺点

在一定程度上，通过系统维护人员即可改变系统的行为（功能)，不需要开发人员的介入。使得系统的变化更快，能及时响应客户和市场的需求；
提高了系统的灵活性、通用性，减少了主体和属性的耦合度；
简化了主体类的业务逻辑
能减少对系统程序的改动，使数据库、程序和页面更稳定。特别是数据量大的时候，能大幅减少开发工作量
使数据库表结构和程序结构条理上更清楚，更容易理解，在可开发性、可扩展性、可维护性、系统强壮性上都有优势。

数据字典的缺点

数据字典是通用的设计，在系统效率上会低一些；
程序算法相对复杂一些；
对于开发人员，需要具备一定抽象思维能力，所以对开发人员的要求较高；

所以，当属性的数量不多时，用第一种数据字典即可。对于大型的，未定型的系统，可以采用第二种数据字典来设计。至于具体的系统里怎么设计，还是要在看实际情况来找寻通用性和效率二者间的平衡。无论怎么做，关系理论和范式仍是基础。
数据字典的设计

设计形式不唯一，可以是xml文件、字符串等形式

在linux下，线程最是小的执行单位（CPU调度的最小单位），每个线程有独立的运行栈和程序计数器(PC);进程是最小的分配资源单位，每个进程都有独立的代码和数据空间（进程上下文）。
Linux内核是不区分进程和线程的,只在用户层面上进行区分。用户态的多线程模型，同一个进程内部有多个线程，所有的线程共享同一个进程的内存空间，进程中定义的全局变量会被所有的线程共享。例如i++在计算机中并不是原子操作，涉及内存取数，计算和写入内存几个环节，而线程的切换有可能发生在上述任何—个环节中间，所以不同的操作顺序很有可能带来意想不到的结果。