- 1.多线程概念描述
- 1.1程序、进程、线程的理解
- 1.2并行与并发的理解
- 1.3使用多线程的优点
- 1.4使用多线程的环境
- 2.创建多线程的两种方式
- 2.1方式一：继承于Thread类
- 2.1方式二：实现Runnable接口
- 2.3两种方式的比较
- 2.4线程常用方法描述
- 3.线程的生命周期
- 3.1JDK中用Thread.State类线程的状态
- 4.线程的同步---安全问题
- 4.1线程安全问题概述
- 4.2解决多线程安全方式一：synchronized代码块
- 4.2解决多线程安全方式二：synchronized方法
- 4.3解决多线程安全方式三：使用lock锁解决线程安全
- 4.4synchronized与Lock的异同
- 4.5线程的死锁问题
- 5.线程的通信
- 5.1sleep()和wait()的区别
- 5.2生产者和消费者问题
🍀程序：
程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一
段静态的代码。
🍀进程：
进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
🍀线程：
1.2并行与并发的理解进程可进一步细化为线程，是一个程序内部的一条执行路径。线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)
🍀单核CPU与多核CPU的理解：
单核CPU：其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
总结：总的来说就是，一个CPU来回切换执行多个任务，只是时间很短看不到罢了。
多核CPU：如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
🍀并行与并发
1.3使用多线程的优点并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。
1.4使用多线程的环境1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验.
2. 提高计算机系统CPU的利用率
3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
2.创建多线程的两种方式 2.1方式一：继承于Thread类1.程序需要同时执行两个或多个任务。
2.程序需要实现一些需要等待的任务时，如用户输入、文件读写 *** 作、网络 *** 作、搜索等。
3. 需要一些后台运行的程序时。
🍀实现步骤：
1.创建一个继承于Thread的子类
2.重写Thread的run()
3.创建Thread的子类对象
4.通过子类对象调用start（）
实现方式展示：
//1.创建一个继承于Thread的子类
class MyThread extends Thread{
//2.重写Thread的run()
@Override
public void run() {
for (int i = 1; i <= 100; i++){
if (i % 2 == 0){
System.out.print(Thread.currentThread().getName()+":"+i+" ");
}
if (i % 10 == 0){
System.out.println();
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thread的子类对象
MyThread myThread = new MyThread();
//问题一、不能通过线程对象.run()的方法启动线程
myThread.run();
//问题二、不能让已经执行一次的线程在启动，要想再执行一次，需要new一个新的线程
MyThread myThread1 = new MyThread();
myThread1.start();
//4.通过子类对象调用start【这个才是调用创建的线程】
myThread.start();//①启动当前线程②调用当前线程的run()
}
}
🍀实现步骤：
1.创建一个实现Runnable接口的实现类
2.实现类去实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此参数作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()
实现方式展示：
class MThread implements Runnable{
//重写run方法
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class ThreadTest2 {
public static void main(String[] args) {
//创建实现类的对象
MThread mThread = new MThread();
//将此参数作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread thread = new Thread(mThread);
//执行start方法
thread.start();
//在创建一个线程
Thread thread1 = new Thread(mThread);
thread1.start();
}
}
2.4线程常用方法描述开发中，优先选择使用实现Runnable接口的方式
原因： 1.实现的方式没有类的单继承的局限性
2.实现的方式更适合处理多个线程有共享数据的情况
🍀方法说明
1.start()启动当前线程，调用当前线程的run()
2.run()通常需要重写Thread里面的此方法，将创建的线程要执行的 *** 作声明在此方法中
3.currentThread()：静态方法，返回当前代码执行的线程
4.getName():获取当前线程的名字
5.setName():设置当前线程的名字
6.yield():释放当前cpu的执行权
7.join():当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
8.sleep((long millitime):令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后
重排队
9.isAlive()：返回boolean，判断线程是否还活着
使用样例：
class MyThread1 extends Thread{
public MyThread1(String name){
super(name);
}
@Override
public void run() {
int i;
for (i = 0; i < 100; i++) {
if (i % 2 == 0 ){
/*try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}*/
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
if (i % 20 == 0){
yield();
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
MyThread1 m1 = new MyThread1("Thread: 1");
//设置分线程的优先级
m1.setPriority(Thread.MAX_PRIORITY);//说明他只是先执行，并不一定是他执行完毕之后，主线程才会执行
m1.start();
//设置当前线程的名字的方法
Thread.currentThread().setName("主线程");
for (int i = 0; i < 100; i++) {
if (i % 2 == 0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
/*if (i == 20){
try {
m1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}*/
}
System.out.println(m1.isAlive());
}
}
🍀文字形式描述：
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建
状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线
程的 *** 作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出 *** 作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
🍀图片形式展示：
🍀问题提出：
多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成 *** 作的不完整性，会破坏数据。
🍀具体问题举例：
当一个景点有三个售票窗口在售票，（每一个窗口代表一个线程）可能会有多个窗口在同时时刻出票，这就可能会出现多个窗口出的票号是一样的----》多线程安全问题就出现了
关于多线程问题的具体阐述：
1. 多线程会出现安全问题
2. 问题的原因：
当多条语句在 *** 作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
3. 解决办法：
对多条 *** 作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
🍀采用多线程实现多窗口售票（有安全问题）
class Window extends Thread {
private static int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号：" + ticket);
ticket--;
}else {
break;
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
//此种执行方法有问题---没有实现异步
//创建三个分线程，代表三个窗口
Window t1 = new Window();
Window t2 = new Window();
Window t3 = new Window();
t1.setName("窗口一");
t2.setName("窗口二");
t3.setName("窗口三");
t1.start();
t2.start();
t3.start();
}
}
🍀使用格式：
synchronized(同步监视器){
//需要被同步的代码
}
🍀 说明（理解很重要，需要细读）：
1. *** 作共享数据的代码，即为需要被同步的代码 注意不能包含的代码多了
2.共享数据：多个线程共同 *** 作的代码。例如：ticket就是共享数据
3.同步监视器：俗称，锁。任何一个类的对象都可以充当锁
4.多个线程必须使用同一个锁
5.同步的方式解决了线程安全问题—》好处
*** 作代码时，只能有一个线程参与，其他的线程等待，相当于是一个单线程，效率低一些—>局限性
🍀具体解决线程安全问题样例：
class MyThread implements Runnable{
private int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true){
synchronized (obj){//解决问题的关键
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":售票，票号是：" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
MyThread m1 = new MyThread();
Thread t1 = new Thread(m1);
Thread t2 = new Thread(m1);
Thread t3 = new Thread(m1);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
🍀使用格式：
private synchronized 返回值类型 方法名(){
}
🍀说明：
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2.非静态方法，同步监视器是this
静态方法，同步监视器是当前类本身
对于同步监视器含义：可以理解为当前正在执行的线程本身
如果 *** 作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的
🍀具体的实现样例：
class Window3 implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true){
show();//把 *** 作共享数据的代码抽离出去，单独建一个方法，使用同步方法的方法，解决线程问题
}
}
private synchronized void show(){
if (ticket > 0){
System.out.println(Thread.currentThread().getName()+":售票，票号是："+ticket);
ticket--;
}
}
}
public class Window3Test {
public static void main(String[] args) {
Window3 w3 = new Window3();
Thread t1 = new Thread(w3);
Thread t2 = new Thread(w3);
Thread t3 = new Thread(w3);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
🍀具体的实现步骤：
1.创建ReentrantLock类的对象
2.将共享数据的代码，使用try–catch包围
3.在try里面实现ReentrantLock类的对象的上锁，在finally里面实现解锁
🍀说明：
此类方法只需要按照步骤执行结束
🍀实现解决线程安全的方式三实现代码：
class Window implements Runnable{
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock();//步骤1
@Override
public void run() {
while (true){
try {
//进行上锁
lock.lock();//步骤2
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":售票，票号是：" + ticket);
ticket--;
} else {
break;
}
}finally {
//解锁
lock.unlock();//步骤3
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w1 = new Window();
Thread t1 = new Thread(w1);
Thread t2 = new Thread(w1);
Thread t3 = new Thread(w1);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
🍀相同点：
二者都可以解决线程安全问题
🍀 不同点：
synchronized机制在执行问相应的同步代码以后，自动释放同步监视器
Lock需要手动的启动同步(lock())，同时在结束的同步时也需要手动关闭(unlock())
🍀 解决线程安全的使用顺序：
Lock ——>同步代码块 ———>同步方法
🍀死锁问题描述：
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
🍀解决死锁问题的方法：
专门的算法、原则
尽量减少同步资源的定义
尽量避免嵌套同步
🍀具体的出现死锁问题描述：
当前有两个线程，两把锁s1,s2；
第一个线程的同步检测器是s1,开始执行如下语句：
synchronized (s1){
s1.append("a");
s2.append("1");
//加入Thread.sleep()之后极有可能会出现死锁
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
执行结束后s1进入阻塞状态（回去执行另一个线程），嵌套了一个同步代码：
synchronized (s2){
s1.append("b");
s2.append("2");
}
第二个线程的同步检测器是s2,开始执行如下语句：
synchronized (s2){
s1.append("c");
s2.append("3");
//出现死锁
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
执行结束后s2进入阻塞状态嵌套了一个同步，开始执行
synchronized (s1){
s1.append("d");
s2.append("4");
}
🍀对于出现死锁问题的具体阐述(理解这个很重要)
线程1拿着锁1 执行s1.append,s2.append之后进入睡眠，这时线程2拿着锁2 执行s2.append,s1.append两个线程很有可能会同时醒来，这时候线程1，需要线程2的资源执行 *** 作，线程2也需要线程1的资源，这时就会处于一个死锁状态，再写的时候应尽量避免死锁状态的出现
🍀完整的代码展示：
public class ThreadTest {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
//线程1拿着锁1 执行s1.append,s2.append之后进入睡眠，这时线程2拿着锁2 执行s2.append,s1.append
//两个线程很有可能会同时醒来，这时候线程1，需要线程2的资源执行 *** 作，线程2也需要线程1的资源，这时就会处于一个死锁状态
//再写的时候应尽量避免死锁状态的出现
//第一个线程一共有两把锁，s1,s2
new Thread(){
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
//加入Thread.sleep()之后极有可能会出现死锁
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);
}
}.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();
}
}
🍀练习
问题描述：
银行有一个账户。
有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打
印账户余额。
具体分析：
是否存在多线程安全问题？ 有两个储户线程
是否有共享数据？ 账户
存在线程安全性问题
🍀具体实现代码：
方式一：
使用继承的方式解决
class Account{
private double balance;
public Account(double balance) {
this.balance = balance;
}
//使用synchronized解决线程安全问题
public synchronized void deposit(double amt){
if (amt > 0){
balance += amt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"存钱成功，余额为："+balance);
}
}
}
class Customer extends Thread{
private Account account;
public Customer(Account account) {
this.account = account;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
account.deposit(1000);
}
}
}
public class AccountTest {
public static void main(String[] args) {
//实现一个账户，创建两个用户
Account acct = new Account(0);
Customer c1 = new Customer(acct);
Customer c2 = new Customer(acct);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
方式一：
采用实现类的方式解决
class Account1{
private double balance;
public Account1(double balance) {
this.balance = balance;
}
public synchronized void deposit(double amt){
if (amt > 0){
balance += amt;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":存钱成功，余额为："+balance);
}
}
}
class Customer1 implements Runnable{
public Account1 account1;
public Customer1(Account1 account1) {
this.account1 = account1;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
account1.deposit(1000);
}
}
}
public class AccountTest2 {
public static void main(String[] args) {
Account1 account = new Account1(0);
Customer1 c1 = new Customer1(account);
Customer1 c2 = new Customer1(account);
Thread t1 = new Thread(c1);
Thread t2 = new Thread(c2);
t1.setName("甲");
t2.setName("乙");
t1.start();
t2.start();
}
}
🍀通信描述：
实现线程之间的交互执行工作
🍀（重点）涉及到的三个方法
wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
notify():一旦执行此方法，就会唤醒wait的一个线程，如果有过个线程，就唤醒，优先级比较高的
notifyall():一旦执行此方法，就会唤醒所有被wait的线程
🍀说明：
5.1sleep()和wait()的区别1.wait()，notify()，notifyall()三个方法必须使用在同步代码块，或者同步方法中
2.wait()，notify()，notifyall()三个方法必须是同步代码块，或者同步方法中的同步监视器，否则会出现异常
3.wait()，notify()，notifyall()三个方法定义在java.long.object中
1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
2.不同点：①两个方法声明的位置不同，Thread类中声明sleep(),Object类中声明wait()
②调用的要求不同，sleep()可以在任何需要的场景中调用，wait()必须使用在同步代码块，或者同步方法中
③关于是否释放同步监视器：如果两个方法都声明在同步代码块或者同步方法中，sleep不会释放锁，wait会释放锁
🍀实 现 例 题：
使用两个线程打印 1-100。线程1, 线程2 交替打印
class Number implements Runnable{
private int number = 1;
@Override
public void run() {
while (true){
synchronized (this) {
notify();//唤醒进入阻塞状态的线程
if (number <= 100) {
System.out.println(Thread.currentThread().getName() + ":" + number);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
number++;
//使用wait()让当前线程进入阻塞状态，同时唤醒另一个线程
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class Communication {
public static void main(String[] args) {
Number n1 = new Number();
Thread t1 = new Thread(n1);
Thread t2 = new Thread(n1);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
🍀问题描述：
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图
生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通
知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如
果店中有产品了再通知消费者来取走产品。
🍀分析：
1.是否是多线程问题？是多线程，生产者线程，消费者线程
2.是否有共享数据？店员（产品数量）
3.如何解决线程的安全问题？同步机制，三种方法，synchronized,Lock,wait和notify
4.是否涉及到线程的通信？是
class Clerk{
private int ProductNumber = 0;
public synchronized void produceProductor() {
if (ProductNumber < 20){
ProductNumber++;
System.out.println(Thread.currentThread().getName()+"开始生产第"+ProductNumber+"个产品");
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void customProductor() {
if (ProductNumber > 0){
System.out.println(Thread.currentThread().getName()+"开始消费第"+ProductNumber+"个产品");
ProductNumber--;
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Producer extends Thread{
private Clerk clerk;
public Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
while (true) {
System.out.println("开始生产产品.....");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProductor();
}
}
}
class Customer extends Thread {
private Clerk clerk;
public Customer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
while (true) {
System.out.println("开始消费产品......");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.customProductor();
}
}
}
public class ProductorTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
Customer c1 = new Customer(clerk);
p1.setName("生产者");
c1.setName("消费者");
p1.start();
c1.start();
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）