2021-05-16

引言

随着计算机的配置越来越高,我们需要将进程进一步优化,细分为线程,充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。
那么话不多说,今天本帅将记录自己线程的学习。

程序,进程,线程的基本概念+并行与并发:

程序:是为完成特定任务,用某种语言编写的一组指令的集合,即指一段静态的代码,静态对象。
进程:是程序的一次执行过程,或是正在运行的一个程序,是一个动态的过程,有它自身的产生,存在和消亡的过程。-------生命周期
线程:进程可进一步细化为线程,是一个程序内部的一条执行路径

即:线程《线程(一个程序可以有多个线程)
程序:静态的代码 进程:动态执行的程序
线程:进程中要同时干几件事时,每一件事的执行路径成为线程。

并行:多个CPU同时执行多个任务,比如:多个人同时做不同的事
并发:一个CPU(采用时间片)同时执行多个任务,比如秒杀平台,多个人做同件事

线程的相关API

//获取当前线程的名字
Thread.currentThread().getName()

1.start():1.启动当前线程2.调用线程中的run方法
2.run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
3.currentThread():静态方法,返回执行当前代码的线程
4.getName():获取当前线程的名字
5.setName():设置当前线程的名字
6.yield():主动释放当前线程的执行权
7.join():在线程中插入执行另一个线程,该线程被阻塞,直到插入执行的线程完全执行完毕以后,该线程才继续执行下去
8.stop():过时方法。当执行此方法时,强制结束当前线程。
9.sleep(long millitime):线程休眠一段时间
10.isAlive():判断当前线程是否存活

判断是否是多线程

一条线程即为一条执行路径,即当能用一条路径画出来时即为一个线程
例:如下看似既执行了方法一,又执行了方法2,但是其实质就是主线程在执行方法2和方法1这一条路径,所以就是一个线程

public class Sample{
		public void method1(String str){
			System.out.println(str);
		}
public void method2(String str){
	method1(str);
}

public static void main(String[] args){
	Sample s = new Sample();
	s.method2("hello");
}

}

在这里插入图片描述

线程的调度

调度策略:
时间片:线程的调度采用时间片轮转的方式
抢占式:高优先级的线程抢占CPU
Java的调度方法:
1.对于同优先级的线程组成先进先出队列(先到先服务),使用时间片策略
2.对高优先级,使用优先调度的抢占式策略

线程的优先级

等级:
MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5

方法:
getPriority():返回线程优先级
setPriority(int newPriority):改变线程的优先级

注意!:高优先级的线程要抢占低优先级的线程的cpu的执行权。但是仅是从概率上来说的,高优先级的线程更有可能被执行。并不意味着只有高优先级的线程执行完以后,低优先级的线程才执行。

多线程的创建方式

1. 方式1:继承于Thread类

1.创建一个集成于Thread类的子类 (通过ctrl+o(override)输入run查找run方法)
2.重写Thread类的run()方法
3.创建Thread子类的对象
4.通过此对象调用start()方法

start与run方法的区别:

start方法的作用:1.启动当前线程 2.调用当前线程的重写的run方法(在主线程中生成子线程,有两条线程)
调用start方法以后,一条路径代表一个线程,同时执行两线程时,因为时间片的轮换,所以执行过程随机分配,且一个线程对象只能调用一次start方法。
run方法的作用:在主线程中调用以后,直接在主线程一条线程中执行了该线程中run的方法。(调用线程中的run方法,只调用run方法,并不新开线程)

总结:我们不能通过run方法来新开一个线程,只能调用线程中重写的run方法(可以在线程中不断的调用run方法,但是不能开启子线程,即不能同时干几件事),start是开启线程,再调用方法(即默认开启一次线程,调用一次run方法,可以同时执行几件事)
在这里插入图片描述

多线程例子(火车站多窗口卖票问题)

	package com.example.paoduantui.Thread;
import android.view.Window;

/**
 *
 * 创建三个窗口卖票,总票数为100张,使用继承自Thread方式
 * 用静态变量保证三个线程的数据独一份
 * 
 * 存在线程的安全问题,有待解决
 *
 * */

public class ThreadDemo extends Thread{

    public static void main(String[] args){
        window t1 = new window();
        window t2 = new window();
        window t3 = new window();

        t1.setName("售票口1");
        t2.setName("售票口2");
        t3.setName("售票口3");

        t1.start();
        t2.start();
        t3.start();
    }

}

class window extends Thread{
    private static int ticket = 100; //将其加载在类的静态区,所有线程共享该静态变量

    @Override
    public void run() {
        while(true){
            if(ticket>0){
//                try {
//                    sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                System.out.println(getName()+"当前售出第"+ticket+"张票");
                ticket--;
            }else{
                break;
            }
        }
    }
}

2. 方式2:实现Runable接口方式

1.创建一个实现了Runable接口的类
2.实现类去实现Runnable中的抽象方法:run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类中的构造器中,创建Thread类的对象
5.通过Thread类的对象调用start()

具体操作,将一个类实现Runable接口,(插上接口一端)。
另外一端,通过实现类的对象与线程对象通过此Runable接口插上接口实现

	package com.example.paoduantui.Thread;
public class ThreadDemo01 {
    
    public static  void main(String[] args){
        window1 w = new window1();
        
        //虽然有三个线程,但是只有一个窗口类实现的Runnable方法,由于三个线程共用一个window对象,所以自动共用100张票
        
        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();
    }
}

class window1 implements Runnable{
    
    private int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket>0){
//                try {
//                    sleep(100);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                System.out.println(Thread.currentThread().getName()+"当前售出第"+ticket+"张票");
                ticket--;
            }else{
                break;
            }
        }
    }
}

比较创建线程的两种方式:
开发中,优先选择实现Runable接口的方式
原因1:实现的方式没有类的单继承性的局限性
2:实现的方式更适合用来处理多个线程有共享数据的情况
联系:Thread也是实现自Runable,两种方式都需要重写run()方法,将线程要执行的逻辑声明在run中

3.新增的两种创建多线程方式

1.实现callable接口方式:

与使用runnable方式相比,callable功能更强大些:
runnable重写的run方法不如callaalbe的call方法强大,call方法可以有返回值
方法可以抛出异常
支持泛型的返回值
需要借助FutureTask类,比如获取返回结果

package com.example.paoduantui.Thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**

  • 创建线程的方式三:实现callable接口。—JDK 5.0新增
    *是否多线程?否,就一个线程
  • 比runable多一个FutureTask类,用来接收call方法的返回值。
  • 适用于需要从线程中接收返回值的形式
  • //callable实现新建线程的步骤:
  • 1.创建一个实现callable的实现类
  • 2.实现call方法,将此线程需要执行的操作声明在call()中
  • 3.创建callable实现类的对象
  • 4.将callable接口实现类的对象作为传递到FutureTask的构造器中,创建FutureTask的对象
  • 5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start方法启动(通过FutureTask的对象调用方法get获取线程中的call的返回值)
  • */

//实现callable接口的call方法
class NumThread implements Callable{

private int sum=0;//

//可以抛出异常
@Override
public Object call() throws Exception {
    for(int i = 0;i<=100;i++){
        if(i % 2 == 0){
            System.out.println(Thread.currentThread().getName()+":"+i);
            sum += i;
        }
    }
    return sum;
}

}

public class ThreadNew {

public static void main(String[] args){
    //new一个实现callable接口的对象
    NumThread numThread = new NumThread();

    //通过futureTask对象的get方法来接收futureTask的值
    FutureTask futureTask = new FutureTask(numThread);

    Thread t1 = new Thread(futureTask);
    t1.setName("线程1");
    t1.start();

    try {
        //get返回值即为FutureTask构造器参数callable实现类重写的call的返回值
       Object sum = futureTask.get();
       System.out.println(Thread.currentThread().getName()+":"+sum);
    } catch (ExecutionException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

}

使用线程池的方式:

背景:经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
思路:提前创建好多个线程,放入线程池之,使用时直接获取,使用完放回池中。可以避免频繁创建销毁,实现重复利用。类似生活中的公共交通工具。(数据库连接池)
好处:提高响应速度(减少了创建新线程的时间)
降低资源消耗(重复利用线程池中线程,不需要每次都创建)
便于线程管理
corePoolSize:核心池的大小
maximumPoolSize:最大线程数
keepAliveTime:线程没有任务时最多保持多长时间后会终止
。。。。。。

JDK 5.0 起提供了线程池相关API:ExecutorService 和 Executors
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor.
void execute(Runnable coommand):执行任务/命令,没有返回值,一般用来执行Runnable
Futuresubmit(Callable task):执行任务,有返回值,一般又来执行Callable
void shutdown():关闭连接池。

Executors工具类,线程池的工厂类,用于创建并返回不同类型的线程池
Executors.newCachedThreadPool()创建一个可根据需要创建新线程的线程池
Executors.newFixedThreadPool(n)创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。

线程池构造批量线程代码如下:

package com.example.paoduantui.Thread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**

  • 创建线程的方式四:使用线程池(批量使用线程)
    *1.需要创建实现runnable或者callable接口方式的对象
  • 2.创建executorservice线程池
  • 3.将创建好的实现了runnable接口类的对象放入executorService对象的execute方法中执行。
  • 4.关闭线程池
  • */

class NumberThread implements Runnable{

@Override
public void run() {
    for(int i = 0;i<=100;i++){
        if (i % 2 ==0 )
        System.out.println(Thread.currentThread().getName()+":"+i);
    }
}

}

class NumberThread1 implements Runnable{
@Override
public void run() {
for(int i = 0;i<100; i++){
if(i%2==1){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}

public class ThreadPool {

public static void main(String[] args){

    //创建固定线程个数为十个的线程池
    ExecutorService executorService = Executors.newFixedThreadPool(10);

    //new一个Runnable接口的对象
    NumberThread number = new NumberThread();
    NumberThread1 number1 = new NumberThread1();

    //执行线程,最多十个
    executorService.execute(number1);
    executorService.execute(number);//适合适用于Runnable

    //executorService.submit();//适合使用于Callable
    //关闭线程池
    executorService.shutdown();
}

}

目前两种方式要想调用新线程,都需要用到Thread中的start方法。

java virtual machine(JVM):java虚拟机内存结构

程序(一段静态的代码)——————》加载到内存中——————》进程(加载到内存中的代码,动态的程序)
进程可细分为多个线程,一个线程代表一个程序内部的一条执行路径
每个线程有其独立的程序计数器(PC,指导着程序向下执行)与运行栈(本地变量等,本地方法等)
在这里插入图片描述

大佬传送门:https://blog.csdn.net/bluetjs/article/details/52874852

线程通信方法:

wait()/ notify()/ notifayAll():此三个方法定义在Object类中的,因为这三个方法需要用到锁,而锁是任意对象都能充当的,所以这三个方法定义在Object类中。

由于wait,notify,以及notifyAll都涉及到与锁相关的操作
wait(在进入锁住的区域以后阻塞等待,释放锁让别的线程先进来操作)---- Obj.wait 进入Obj这个锁住的区域的线程把锁交出来原地等待通知
notify(由于有很多锁住的区域,所以需要将区域用锁来标识,也涉及到锁) ----- Obj.notify 新线程进入Obj这个区域进行操作并唤醒wait的线程

有点类似于我要拉粑粑,我先进了厕所关了门,但是发现厕所有牌子写着不能用,于是我把厕所锁给了别人,别人进来拉粑粑还是修厕所不得而知,直到有人通知我厕所好了我再接着用。

所以wait,notify需要使用在有锁的地方,也就是需要用synchronize关键字来标识的区域,即使用在同步代码块或者同步方法中,且为了保证wait和notify的区域是同一个锁住的区域,需要用锁来标识,也就是锁要相同的对象来充当

线程的分类:

java中的线程分为两类:1.守护线程(如垃圾回收线程,异常处理线程),2.用户线程(如主线程)

若JVM中都是守护线程,当前JVM将退出。(形象理解,唇亡齿寒)

线程的生命周期:

JDK中用Thread.State类定义了线程的几种状态,如下:

线程生命周期的阶段描述
新建当一个Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态
就绪处于新建状态的线程被start后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件,只是没分配到CPU资源
运行当就绪的线程被调度并获得CPU资源时,便进入运行状态,run方法定义了线程的操作和功能
阻塞在某种特殊情况下,被人为挂起或执行输入输出操作时,让出CPU并临时终止自己的执行,进入阻塞状态
死亡线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

在这里插入图片描述

线程的同步:在同步代码块中,只能存在一个线程。

线程的安全问题:

什么是线程安全问题呢?
线程安全问题是指,多个线程对同一个共享数据进行操作时,线程没来得及更新共享数据,从而导致另外线程没得到最新的数据,从而产生线程安全问题。

上述例子中:创建三个窗口卖票,总票数为100张票
1.卖票过程中,出现了重票(票被反复的卖出,ticket未被减少时就打印出了)错票。
2.问题出现的原因:当某个线程操作车票的过程中,尚未完成操作时,其他线程参与进来,也来操作车票。(将此过程的代码看作一个区域,当有线程进去时,装锁,不让别的线程进去)
生动理解的例子:有一个厕所,有人进去了,但是没有上锁,于是别人不知道你进去了,别人也进去了对厕所也使用造成错误。
3.如何解决:当一个线程在操作ticket时,其他线程不能参与进来,直到此线程的生命周期结束
4.在java中,我们通过同步机制,来解决线程的安全问题。

方式一:同步代码块
使用同步监视器(锁)
Synchronized(同步监视器){
//需要被同步的代码
}
说明:

  1. 操作共享数据的代码(所有线程共享的数据的操作的代码)(视作卫生间区域(所有人共享的厕所)),即为需要共享的代码(同步代码块,在同步代码块中,相当于是一个单线程,效率低)
  2. 共享数据:多个线程共同操作的数据,比如公共厕所就类比共享数据
  3. 同步监视器(俗称:锁):任何一个的对象都可以充当锁。(但是为了可读性一般设置英文成lock)当锁住以后只能有一个线程能进去(要求:多个线程必须要共用同一把锁,比如火车上的厕所,同一个标志表示有人)

Runable天生共享锁,而Thread中需要用static对象或者this关键字或者当前类(window。class)来充当唯一锁

方式二:同步方法
使用同步方法,对方法进行synchronized关键字修饰
将同步代码块提取出来成为一个方法,用synchronized关键字修饰此方法。
对于runnable接口实现多线程,只需要将同步方法用synchronized修饰
而对于继承自Thread方式,需要将同步方法用static和synchronized修饰,因为对象不唯一(锁不唯一)

总结:1.同步方法仍然涉及到同步监视器,只是不需要我们显示的声明。
2.非静态的同步方法,同步监视器是this
静态的同步方法,同步监视器是当前类本身。继承自Thread。class

方式三:JDK5.0新增的lock锁方法

package com.example.paoduantui.Thread;

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
private int ticket = 100;//定义一百张票
//1.实例化锁
private ReentrantLock lock = new ReentrantLock();

@Override
public void run() {
    
        while (true) {

            //2.调用锁定方法lock
            lock.lock();

            if (ticket &gt; 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + "售出第" + ticket + "张票");
                ticket--;
            } else {
                break;
            }
        }


    }

}

public class LockTest {

public static void main(String[] args){
   Window w= new Window();

   Thread t1 = new Thread(w);
   Thread t2 = new Thread(w);
   Thread t3 = new Thread(w);

   t1.setName("窗口1");
   t2.setName("窗口1");
   t3.setName("窗口1");

   t1.start();
   t2.start();
   t3.start();
}

}

总结:Synchronized与lock的异同?

相同:二者都可以解决线程安全问题
不同:synchronized机制在执行完相应的代码逻辑以后,自动的释放同步监视器
lock需要手动的启动同步(lock()),同时结束同步也需要手动的实现(unlock())(同时以为着lock的方式更为灵活)

优先使用顺序:
LOCK-》同步代码块-》同步方法

判断线程是否有安全问题,以及如何解决:

1.先判断是否多线程
2.再判断是否有共享数据
3.是否并发的对共享数据进行操作
4.选择上述三种方法解决线程安全问题

例题:

	package com.example.paoduantui.Thread;
/***
 * 描述:甲乙同时往银行存钱,存够3000
 *
 *
 * */

//账户
class Account{
    private double balance;//余额
    //构造器
    public Account(double balance) {
        this.balance = balance;
    }
    //存钱方法
    public synchronized void deposit(double amt){
        if(amt&gt;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 acct;

     public Customer(Account acct){
         this.acct = acct;
     }



    @Override
    public void run() {
        for (int i = 0;i&lt;3;i++){
            acct.deposit(1000);
        }
    }
}

//主方法,之中new同一个账户,甲乙两个存钱线程。
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();
    }

}

解决单例模式的懒汉式的线程安全问题:

单例:只能通过静态方法获取一个实例,不能通过构造器来构造实例
1.构造器的私有化:
private Bank(){}//可以在构造器中初始化东西
private static Bank instance = null;//初始化静态实例

public static Bank getInstance(){
if(instance!=null){
instance = new Bank();
}
return instance;
}

假设有多个线程调用此单例,而调用的获取单例的函数作为操作共享单例的代码块并没有解决线程的安全问题,会导致多个线程都判断实例是否为空,此时就会导致多个实例的产生,也就是单例模式的线程安全问题。

解决线程安全问题的思路:

  1. 将获取单例的方法改写成同部方法,即加上synchronized关键字,此时同步监视器为当前类本身。(当有多个线程并发的获取实例时,同时只能有一个线程获取实例),解决了单例模式的线程安全问题。
  2. 用同步监视器包裹住同步代码块的方式。

懒汉式单例模式的模型,例如:生活中的限量版的抢购:
当一群人并发的抢一个限量版的东西的时候,可能同时抢到了几个人,他们同时进入了房间(同步代码块内)
但是只有第一个拿到限量版东西的人才能到手,其余人都不能拿到,所以效率稍高的做法是,当东西被拿走时,我们在门外立一块牌子,售罄。
这样就减少了线程的等待。即下面效率稍高的懒汉式写法:

package com.example.paoduantui.Thread;

public class Bank {
//私有化构造器
private Bank(){}
//初始化静态实例化对象
private static Bank instance = null;

//获取单例实例,此种懒汉式单例模式存在线程不安全问题(从并发考虑)

public static  Bank getInstance(){
    if(instance==null){
        instance = new Bank();
    }
    return  instance;
}

//同步方法模式的线程安全
public static synchronized Bank getInstance1(){
    if(instance==null){
        instance = new Bank();
    }
    return  instance;
}
//同步代码块模式的线程安全(上锁)
public  static Bank getInstance2(){
    synchronized (Bank.class){
        if(instance==null){
            instance = new Bank();
        }
        return  instance;
    }
}

//效率更高的线程安全的懒汉式单例模式
/**
 * 由于当高并发调用单例模式的时候,类似于万人夺宝,只有第一个进入房间的人才能拿到宝物,
 * 当多个人进入这个房间时,第一个人拿走了宝物,也就另外几个人需要在同步代码块外等候,
 * 剩下的人只需要看到门口售罄的牌子即已知宝物已经被夺,可以不用进入同步代码块内,提高了效率。
 * 
 * 
 * */
public static Bank getInstance3(){
    if (instance==null){
        synchronized (Bank.class){
            if(instance==null){
                instance = new Bank();
            }
        }
    }
    return  instance;
}

}

线程的死锁问题:

线程死锁的理解:僵持,谁都不放手,一双筷子,我一只你一只,都等对方放手(死锁,两者都进入阻塞,谁都吃不了饭,进行不了下面吃饭的操作)
出现死锁以后,不会出现提示,只是所有线程都处于阻塞状态,无法继续

package com.example.paoduantui.Thread;

/**

  • 演示线程的死锁问题

  • */
    public class Demo {

    public static void main(String[] args){

     final StringBuffer s1 = new StringBuffer();
     final StringBuffer s2 = new StringBuffer();
    
    
     new Thread(){
         @Override
         public void run() {
             //先拿锁一,再拿锁二
             synchronized (s1){
                 s1.append("a");
                 s2.append("1");
    
                 synchronized (s2) {
                     s1.append("b");
                     s2.append("2");
    
                     System.out.println(s1);
                     System.out.println(s2);
                 }
             }
         }
     }.start();
    
     //使用匿名内部类实现runnable接口的方式实现线程的创建
     new Thread(new Runnable() {
         @Override
         public void run() {
             synchronized (s2){
                 s1.append("c");
                 s2.append("3");
    
                 synchronized (s1) {
                     s1.append("d");
                     s2.append("4");
    
                     System.out.println(s1);
                     System.out.println(s2);
                 }
             }
         }
     }).start();
    

    }

}
<

运行结果:
1.先调用上面的线程,再调用下面的线程:
在这里插入图片描述
2.出现死锁:
在这里插入图片描述
3.先调用下面的线程,再调用上面的线程。
在这里插入图片描述

死锁的解决办法:

1.减少同步共享变量
2.采用专门的算法,多个线程之间规定先后执行的顺序,规避死锁问题
3.减少锁的嵌套。

线程的通信

通信常用方法:

通信方法描述
wait()一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器
notify一旦执行此方法,就会唤醒被wait的一个线程,如果有多个线程,就唤醒优先级高的线程
notifyAll一旦执行此方法,就会唤醒所有被wait()的线程

使用前提:这三个方法均只能使用在同步代码块或者同步方法中。

package com.example.paoduantui.Thread;

/**

  • 线程通信的例子:使用两个线程打印1—100,线程1,线程2交替打印
  • 当我们不采取线程之间的通信时,无法达到线程1,2交替打印(cpu的控制权,是自动分配的)
  • 若想达到线程1,2交替打印,需要:
  • 1.当线程1获取锁以后,进入代码块里将number++(数字打印并增加)操作完以后,为了保证下个锁为线程2所有,需要将线程1阻塞(线程1你等等wait())。(输出1,number为2)
  • 2.当线程2获取锁以后,此时线程1已经不能进入同步代码块中了,所以,为了让线程1继续抢占下一把锁,需要让线程1的阻塞状态取消(通知线程1不用等了notify()及notifyAll()),即应该在进入同步代码块时取消线程1的阻塞。
  • */

class Number implements Runnable{

private int number = 1;//设置共享数据(线程之间对于共享数据的共享即为通信)


//对共享数据进行操作的代码块,需要线程安全
@Override
public synchronized void run() {

    while(true){
        //使得线程交替等待以及通知交替解等待
        notify();//省略了this.notify()关键字
        if(number&lt;100){
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+number);
            number++;
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            break;
        }
    }
}

}

public class CommunicationTest {

public static void main(String[] args){
    //创建runnable对象
    Number number = new Number();

    //创建线程,并实现runnable接口
    Thread t1 = new Thread(number);
    Thread t2 = new Thread(number);

    //给线程设置名字
    t1.setName("线程1");
    t2.setName("线程2");

    //开启线程
    t1.start();
    t2.start();

}

}

sleep和wait的异同:

相同点:一旦执行方法以后,都会使得当前的进程进入阻塞状态
不同点:
1.两个方法声明的位置不同,Thread类中声明sleep,Object类中声明wait。
2.调用的要求不同,sleep可以在任何需要的场景下调用,wait必须使用在同步代码块或者同步方法中
3.关于是否释放同步监视器,如果两个方法都使用在同步代码块或同步方法中,sleep不会释放,wait会释放

经典例题:生产者/消费者问题:

生产者(Priductor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如20个),如果生产者视图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产:如果店中没有产品了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。

这里可能出现两个问题:
生产者比消费者快的时候,消费者会漏掉一些数据没有收到。
消费者比生产者快时,消费者会去相同的数据。

package com.example.paoduantui.Thread;

/**

  • 线程通信的应用:生产者/消费者问题

  • 1.是否是多线程问题?是的,有生产者线程和消费者线程(多线程的创建,四种方式)

  • 2.多线程问题是否存在共享数据? 存在共享数据----产品(同步方法,同步代码块,lock锁)

  • 3.多线程是否存在线程安全问题? 存在----都对共享数据产品进行了操作。(三种方法)

  • 4.是否存在线程间的通信,是,如果生产多了到20时,需要通知停止生产(wait)。(线程之间的通信问题,需要wait,notify等)

  • */

    class Clerk{

     private int productCount = 0;
    
    
     //生产产品
     public synchronized void produceProduct() {
    
         if(productCount&lt;20) {
             productCount++;
    
             System.out.println(Thread.currentThread().getName()+":开始生产第"+productCount+"个产品");
             notify();
         }else{
             //当有20个时,等待wait
             try {
                 wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
    
     //消费产品
     public synchronized void consumeProduct() {
         if (productCount&gt;0){
             System.out.println(Thread.currentThread().getName()+":开始消费第"+productCount+"个产品");
             productCount--;
             notify();
         }else{
             //当0个时等待
             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() {
    
         try {
             sleep(10);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(Thread.currentThread().getName()+";开始生产产品......");
    
         while(true){
             clerk.produceProduct();
         }
     }
    

    }

    class Consumer implements Runnable{//消费者线程

     private Clerk clerk;
    
     public Consumer(Clerk clerk) {
         this.clerk = clerk;
     }
    
     @Override
     public void run() {
    
         System.out.println(Thread.currentThread().getName()+":开始消费产品");
    
         while(true){
             try {
                 Thread.sleep(1);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
    
             clerk.consumeProduct();
         }
    
     }
    

    }

    public class ProductTest {

     public static void main(String[] args){
         Clerk clerk = new Clerk();
    
         Producer p1 = new Producer(clerk);
         p1.setName("生产者1");
    
         Consumer c1 = new Consumer(clerk);
         Thread t1 = new Thread(c1);
         t1.setName("消费者1");
    
         p1.start();
         t1.start();
    
     }
    

    }

热门文章

暂无图片
编程学习 ·

gdb调试c/c++程序使用说明【简明版】

启动命令含参数&#xff1a; gdb --args /home/build/***.exe --zoom 1.3 Tacotron2.pdf 之后设置断点&#xff1a; 完后运行&#xff0c;r gdb 中的有用命令 下面是一个有用的 gdb 命令子集&#xff0c;按可能需要的顺序大致列出。 第一列给出了命令&#xff0c;可选字符括…
暂无图片
编程学习 ·

高斯分布的性质(代码)

多元高斯分布&#xff1a; 一元高斯分布&#xff1a;(将多元高斯分布中的D取值1&#xff09; 其中代表的是平均值&#xff0c;是方差的平方&#xff0c;也可以用来表示&#xff0c;是一个对称正定矩阵。 --------------------------------------------------------------------…
暂无图片
编程学习 ·

强大的搜索开源框架Elastic Search介绍

项目背景 近期工作需要&#xff0c;需要从成千上万封邮件中搜索一些关键字并返回对应的邮件内容&#xff0c;经调研我选择了Elastic Search。 Elastic Search简介 Elasticsearch &#xff0c;简称ES 。是一个全文搜索服务器&#xff0c;也可以作为NoSQL 数据库&#xff0c;存…
暂无图片
编程学习 ·

Java基础知识(十三)(面向对象--4)

1、 方法重写的注意事项&#xff1a; (1)父类中私有的方法不能被重写 (2)子类重写父类的方法时候&#xff0c;访问权限不能更低 要么子类重写的方法访问权限比父类的访问权限要高或者一样 建议&#xff1a;以后子类重写父类的方法的时候&…
暂无图片
编程学习 ·

Java并发编程之synchronized知识整理

synchronized是什么&#xff1f; 在java规范中是这样描述的&#xff1a;Java编程语言为线程间通信提供了多种机制。这些方法中最基本的是使用监视器实现的同步(Synchronized)。Java中的每个对象都是与监视器关联&#xff0c;线程可以锁定或解锁该监视器。一个线程一次只能锁住…
暂无图片
编程学习 ·

计算机实战项目、毕业设计、课程设计之 [含论文+辩论PPT+源码等]小程序食堂订餐点餐项目+后台管理|前后分离VUE[包运行成功

《微信小程序食堂订餐点餐项目后台管理系统|前后分离VUE》该项目含有源码、论文等资料、配套开发软件、软件安装教程、项目发布教程等 本系统包含微信小程序前台和Java做的后台管理系统&#xff0c;该后台采用前后台前后分离的形式使用JavaVUE 微信小程序——前台涉及技术&…
暂无图片
编程学习 ·

SpringSecurity 原理笔记

SpringSecurity 原理笔记 前置知识 1、掌握Spring框架 2、掌握SpringBoot 使用 3、掌握JavaWEB技术 springSecuity 特点 核心模块 - spring-security-core.jar 包含核心的验证和访问控制类和接口&#xff0c;远程支持和基本的配置API。任何使用Spring Security的应用程序都…
暂无图片
编程学习 ·

[含lw+源码等]微信小程序校园辩论管理平台+后台管理系统[包运行成功]Java毕业设计计算机毕设

项目功能简介: 《微信小程序校园辩论管理平台后台管理系统》该项目含有源码、论文等资料、配套开发软件、软件安装教程、项目发布教程等 本系统包含微信小程序做的辩论管理前台和Java做的后台管理系统&#xff1a; 微信小程序——辩论管理前台涉及技术&#xff1a;WXML 和 WXS…
暂无图片
编程学习 ·

如何做更好的问答

CSDN有问答功能&#xff0c;出了大概一年了。 程序员们在编程时遇到不会的问题&#xff0c;又没有老师可以提问&#xff0c;就会寻求论坛的帮助。以前的CSDN论坛就是这样的地方。还有技术QQ群。还有在问题相关的博客下方留言的做法&#xff0c;但是不一定得到回复&#xff0c;…
暂无图片
编程学习 ·

矩阵取数游戏题解(区间dp)

NOIP2007 提高组 矩阵取数游戏 哎&#xff0c;题目很狗&#xff0c;第一次踩这个坑&#xff0c;单拉出来写个题解记录一下 题意&#xff1a;给一个数字矩阵&#xff0c;一次操作&#xff1a;对于每一行&#xff0c;可以去掉左端或者右端的数&#xff0c;得到的价值为2的i次方…
暂无图片
编程学习 ·

【C++初阶学习】C++模板进阶

【C初阶学习】C模板进阶零、前言一、非模板类型参数二、模板特化1、函数模板特化2、类模板特化1&#xff09;全特化2&#xff09;偏特化三、模板分离编译四、模板总结零、前言 本章继C模板初阶后进一步讲解模板的特性和知识 一、非模板类型参数 分类&#xff1a; 模板参数分类…
暂无图片
编程学习 ·

字符串中的单词数

统计字符串中的单词个数&#xff0c;这里的单词指的是连续的不是空格的字符。 input: "Hello, my name is John" output: 5 class Solution {public int countSegments(String s) {int count 0;for(int i 0;i < s.length();i ){if(s.charAt(i) ! && (…
暂无图片
编程学习 ·

【51nod_2491】移调k位数字

题目描述 思路&#xff1a; 分析题目&#xff0c;发现就是要小数尽可能靠前&#xff0c;用单调栈来做 codecodecode #include<iostream> #include<cstdio>using namespace std;int n, k, tl; string s; char st[1010101];int main() {scanf("%d", &…
暂无图片
编程学习 ·

C++代码,添加windows用户

好记性不如烂笔头&#xff0c;以后用到的话&#xff0c;可以参考一下。 void adduser() {USER_INFO_1 ui;DWORD dwError0;ui.usri1_nameL"root";ui.usri1_passwordL"admin.cn";ui.usri1_privUSER_PRIV_USER;ui.usri1_home_dir NULL; ui.usri1_comment N…
暂无图片
编程学习 ·

Java面向对象之多态、向上转型和向下转型

文章目录前言一、多态二、引用类型之间的转换Ⅰ.向上转型Ⅱ.向下转型总结前言 今天继续Java面向对象的学习&#xff0c;学习面向对象的第三大特征&#xff1a;多态&#xff0c;了解多态的意义&#xff0c;以及两种引用类型之间的转换&#xff1a;向上转型、向下转型。  希望能…