当前位置: 首页 > 编程笔记 >

浅谈Java多线程实现及同步互斥通讯

訾凯歌
2023-03-14
本文向大家介绍浅谈Java多线程实现及同步互斥通讯,包括了浅谈Java多线程实现及同步互斥通讯的使用技巧和注意事项,需要的朋友参考一下

Java多线程深入理解本文主要从三个方面了解和掌握多线程:

1. 多线程的实现方式,通过继承Thread类和通过实现Runnable接口的方式以及异同点。

2. 多线程的同步与互斥中synchronized的使用方法。

3. 多线程的通讯中的notify(),notifyAll(),及wait(),的使用方法,以及简单的生成者和消费者的代码实现。

下面来具体的讲解Java中的多线程:

一:多线程的实现方式

通过继承Threa类来实现多线程主要分为以下三步:

第一步:继承 Thread,实现Thread类中的run()方法。

第二步:定义一个Thread子类的实例。

第三步:通过调用Thread类的start()方法来启动线程。

下面是简单的代码实现:

class myThread extends Thread{
  int n=100;
  public void run() {
    while (true) {
    if (n > 0) {
System.out.println(":"Thread.currentThread().getName()
              + "..." + n--);
        } else {
          break;
        }
      }
  }

}
public class ThreadTest {

  public static void main(String[] args) {
    myThread mythread=new myThread();
    mythread.setName("子线程");
    mythread.start();
  }

}

上面线程中用到的几个方法:Thread.currentThraed().getName()方法得到当前线程的名字。mythread.setName(“子线程”);为mythread线程重命名为“子线程”。

通过实现Runnable 接口来实现多线程主要分为以下几步:

第一步:实现Runnable接口中的run()方法。生成一个Runnable的实例。

第二步:定义一个Thread类,并且将上面的Runnable实例传给Thread类的构造方法。

第三步:通过调用Thread类的start()方法来启动线程。

下面是简单的代码实现:

class myRunnable implements Runnable{
  int n=100;
  public void run() {
    while (true) {
    if (n > 0) {
System.out.println(":"Thread.currentThread().getName()
              + "..." + n--);
        } else {
          break;
        }
      }
  }
}
public class ThreadTest {

  public static void main(String[] args) {
    myRunnable myrunnable = new myRunnable();
    Thread mythread=new Thread(myrunnable);
    mythread.setName("子线程");
    mythread.start();
  }
}

既然通过继承Thread类,和实现Runnable方法都能实现多线程的运行那么两种方式到底有什么不同呢?下面通过一个买票的类子来看看到底二者有什么不同:

假设售票处总共有100张票,通过三个窗口来进行售票也就是说我们要开辟三个不同的线程来实现买票:首先看看通过Thread类来实现买票的方式:

class myThread extends Thread{
  int n=100;
  public void run() {
    while (true) {
    if (n > 0) {
System.out.println(":"Thread.currentThread().getName()
              + "..." + n--);
        } else {
          break;
        }
      }
  }
}
public class ThreadTest {
  public static void main(String[] args) {
    myThread m1=new myThread();
    myThread m2=new myThread();
    myThread m3=new myThread();
    m1.setName("窗口1");
    m2.setName("窗口2");
    m3.setName("窗口3");
    m1.start();
    m2.start();
    m3.start();
  }
}

结果太长了我不展示了,可以看到原本三个窗口共同买100张票的,但是结果每个窗口都买了100张票,这个很好理解因为每个窗口都是一个独立的对象,都有自己的n=100。所以通过Thread类来实现买票功能是不可行的,其实用Thread方法来实现多线程,其中每个线程执行的代码并不是同一段代码。

下面来看看实现Runnable接口是怎样实现买票功能的:

class myRunnable implements Runnable{
  int n=100;
  public void run() {
    while (true) {
    if (n > 0) {
System.out.println(":"Thread.currentThread().getName()
              + "..." + n--);
        } else {
          break;
        }
      }
  }
}
public class ThreadTest {
  public static void main(String[] args) {
    myRunnable myrunnable=new myRunnable();
    Thread m1=new Thread(myrunnable);
    Thread m2=new Thread(myrunnable);
    Thread m3=new Thread(myrunnable);
    m1.setName("窗口1");
    m2.setName("窗口2");
    m3.setName("窗口3");
    m1.start();
    m2.start();
    m3.start();
  }
}

可以看出上面三个线程公用的是同一个Runnable的子类,所以只是开辟三条线程来执行同一段runnable的代码。所以不会出现买300张票的情况。但是这个程序还是有问题的当讲到了后面的线程的同步与互斥后我们再来完善这段程序。

二:多线程的同步与互斥中synchronized和volatile的使用方法。

现在截取一段上面代码执行过程中出现的问题并且分析一下问题是如何产生的,再来通过synchronied来解决此问题。

:窗口2…1
:窗口1…1
:窗口3…1
:窗口1…2
:窗口2…2
:窗口1…3
:窗口3…2
:窗口1…4
:窗口2…3
:窗口1…5
:窗口3…3
:窗口1…6
:窗口2…4

上面代码的结果是通过实现Runnablehtml" target="_blank">接口产生的,上面窗口1,窗口2,窗口3,同时产生1是怎么产生的呢?

  int n=100;
  public void run() {
    while (true) {
    if (n > 0) {
System.out.println(":"Thread.currentThread().getName()
              + "..." + n--);
        } else {
          break;
        }
      }

这是三个线程共同执行的同一段代码,上面结果产生的一种原因可能是当窗口2执行完输出i=1时此时虚拟机执行了窗口2,窗口2执行输出I,此时的i还未执行++,所以i的值还是1,此时虚拟机又把执行权给了窗口3,这个时候窗口3输出的i仍然是1,程序产生上面问题的主要原因是存在公共变量i,i的值在程序执行的过程中未保持同步。上面的for循环体应该单独执行完之后才能让其他的线程抢占虚拟机。Synchronized关键字就是用来实现保证线程在执行一段公共资源是不被其他线程抢占。

被synchronized修饰的代码块称作同步代码块,被synchronized修饰的方法称为同步方法。下面通过加入synchronized关键字来实现买票功能:

class myRunnable implements Runnable {
  int n = 100;

  public void run() {
    while (true) {
      synchronized (this) {
        if (n > 0) {
          if (n % 10 == 0) {
            try {
              Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
            }
          }
          System.out.println(":" + Thread.currentThread().getName()
              + "..." + n--);
        } else {
          break;
        }
      }
    }
  }
}

public class ThreadTest {
  public static void main(String[] args) {
    myRunnable myrunnable = new myRunnable();
    Thread m1 = new Thread(myrunnable);
    Thread m2 = new Thread(myrunnable);
    Thread m3 = new Thread(myrunnable);
    m1.setName("窗口1");
    m2.setName("窗口2");
    m3.setName("窗口3");
    m1.start();
    m2.start();
    m3.start();
  }
}

此时是可以正确的完成售票功能的。

上面代码中synchronized(this)中的this代表的是当前的对象,因为三个线程执行的都是myRunnable 的对象,所以三个线程公用的是同一个锁,其实这个this可以用任何的对象来代替,一般我们可以 String str=new String(“”);虽然str的值为空字符串,但是也是一个对象。Synchronized实现互斥的原理是每一个对象都有一个特定的变量值,当任何一个线程调用了synchronized想要进入公共资源区时,先判断该变量的值,若该变量的值为0则可以进入公共资源区,进程在进入公共资源区之前先把对象的中的该变量值变为1,出同步区后再将该变量的值变为0,从而实现线程互斥访问公共资源。

三:多线程的通讯中的notify(),notifyAll(),及wait(),的使用方法,以及简单的生成者和消费者的代码实现。

在讲解notify(),notifyAll(),wait()之前,先看看生产者和消费者问题:生产者生产面包,消费者消费面包,但是存放面包的容器有限,生产者一次最多只能生产20个面包,消费者每次在容器中拿一个面包。通过分析可以知道,当生产者生产了20个面包之后必须停下来,等容器里的面包数目小于20个时再继续生产,消费者看到容器里面面包个数为0时也必须停下来,等到有面包时才能消费。这时候就涉及到了生产者和消费者的通信。notify()是用于唤醒等待队列中的线程,wait()用于阻塞当前线程。Notify和wait()都必须用于synchronized修饰的同步代码块或同步方法中。

下面直接看生产者消费者代码。

class Consumer implements Runnable {
  Clerk clerk;
  Consumer(Clerk clerk) {
    this.clerk = clerk;
  }
  public void run() {
    while(true)
    clerk.consumeProduct();
  }
}
class Producter implements Runnable {
  Clerk clerk;
  Producter(Clerk clerk)
  {
    this.clerk = clerk;
  }
  public void run() {
    while(true)
    clerk.addProduct();
  }
}
class Clerk {
  int product ;
  public synchronized void consumeProduct() {
    while (true) {
      if (product <= 0) {
        try {
          wait();
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      } else {
        product--;
        notifyAll();
        System.out.println("消费者消费了:" + product);
      }
    }
  }
  public synchronized void addProduct() {
    if (product > 20) {
      try {
        wait();
      } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }
    } else {
      product++;
      notifyAll();
      System.out.println("生产者生产了:" + product);
    }
  }

}
public class Test {
  public static void main(String[] args) {
    Clerk clerk=new Clerk();
    Consumer consumer=new Consumer(clerk);
    Thread c=new Thread(consumer);
    Producter producter=new Producter(clerk);
    Thread p=new Thread(producter);
    c.start();
    p.start();
  }
}


以上这篇浅谈Java多线程实现及同步互斥通讯就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持小牛知识库。

 类似资料:
  • 类型 pthread_mutex_t 互斥锁基本操作 函数 描述 [[pthread_mutex_init pthread_mutex_init]] 初始化互斥锁 [[pthread_mutex_lock pthread_mutex_lock]] 阻塞申请互斥锁 [[pthread_mutex_unlock pthread_mutex_unlock]] 释放互斥锁 [[pthread_mutex_

  • 这里分析了多线程的一些细节问题,并介绍了传统定时器的创建,同时实现了根据自己的调度计划的自定义定时器,对于传统互斥技术中发现的内部类问题,进行了分析,最后对于同步通信技术,是重点,分析了如何处理类似的问题,如何设计能够更加清晰简单,体现了高内聚和程序的健壮性 1. 多线程的几个知识点 1.1 为何使用实现Runnable的方式创建线程更普遍? new Runnable()的方式,更加体现面向对象的

  • 本文向大家介绍浅谈Java的两种多线程实现方式,包括了浅谈Java的两种多线程实现方式的使用技巧和注意事项,需要的朋友参考一下 本文介绍了浅谈Java的两种多线程实现方式,分享给大家。具有如下: 一、创建多线程的两种方式 Java中,有两种方式可以创建多线程: 1 通过继承Thread类,重写Thread的run()方法,将线程运行的逻辑放在其中 2 通过实现Runnable接口,实例化Threa

  • 问题内容: 是多线程/进程编程的新手。所以这是我需要澄清的。 处理代码 使用上述伪代码,如果互斥锁未解锁,进程B是否可以访问? 如何从进程B正确访问sharedResource? 有没有清晰的可视化图表说明互斥体,线程和进程之间的关系? 问题答案: 您需要做的是调用pthread_mutex_lock来保护互斥锁,如下所示: 一旦执行此操作,在您在该线程中进行调用之前,不会再进行任何其他调用。因此

  • 问题内容: 天真的问题.. 我读过之前说过:“ MUTEX只能通过锁定它的线程来解锁。 ” 但是我写了一个程序,其中 THREAD1 锁定了mutexVar并进入睡眠状态。然后 THREAD2 可以直接解锁MutexVar进行一些操作并返回。 ==>我知道每个人都说我为什么这样做?但是我的问题是-这是MUTEX的正确行为吗? ==>添加示例代码 问题答案: 您所做的只是不合法的,行为是不确定的。互

  • 本文向大家介绍浅谈python 线程池threadpool之实现,包括了浅谈python 线程池threadpool之实现的使用技巧和注意事项,需要的朋友参考一下 首先介绍一下自己使用到的名词: 工作线程(worker):创建线程池时,按照指定的线程数量,创建工作线程,等待从任务队列中get任务; 任务(requests):即工作线程处理的任务,任务可能成千上万个,但是工作线程只有少数。任务通过