服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - JAVA多线程知识汇总

JAVA多线程知识汇总

2020-07-30 15:01搁浅Lee Java教程

这篇文章主要介绍了JAVA多线程的相关资料,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下

线程概念

进程:启动一个应用程序就叫一个进程。 接着又启动一个应用程序,这叫两个进程。每个进程都有一个独立的内存空间;进程也是程序的一次执行过程,是系统运行程序的基本单位;系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程:线程是在进程内部同时做的事情,一个进程中可以有多个线程,这个应用程序也可以称之为多线程程序。

一个程序运行后至少有一个进程,一个进程中可以包含多个线程

线程调度:

  • 分时调度:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。
  • 抢占式调度:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度。

创建多线程

方法一:创建Thread类的子类

  • 创建Thread类的子类,并重写该类的run()方法,设置线程任务。
  • 创建Thread子类的实例,即创建了线程对象
  • 调用线程对象的start()方法来启动该线程
?
1
2
3
4
5
6
7
8
9
10
//方法一:
//定义Thread类的子类,并重写该类的run()方法
public class MyThreadDemo01 extends Thread {
  @Override
  public void run() {
    for (int i = 0; i < 20 ; i++) {
      System.out.println(getName()+"-->"+i);
    }
  }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//主线程
public class MainThread01 {
  public static void main(String[] args) {
    //创建Thread子类的实例,即创建了线程对象
    MyThreadDemo01 thread01 = new MyThreadDemo01();
 
    //调用线程对象的start()方法来启动该线程
    thread01.start();
 
    for (int i = 0; i < 10 ; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}

public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

public String getName() :获取当前线程名称。

public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。

public void run() :此线程要执行的任务在此处定义代码。

public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。

方法二:实现Runnable接口

  • 定义Runnable接口的实现类,并重写该接口的run()方法,设置线程任务
  • 创建Runnable实现类对象
  • 创建Thread类的对象,并且该对象构造方法中传递Runnable实现类对象
  • 调用Thread对象的start()方法来启动线程
?
1
2
3
4
5
6
7
8
9
10
//方法二:
//定义Runnable接口的实现类,并重写该接口的run()方法,设置线程任务
public class MyThreadDemo02 implements Runnable{
  @Override
  public void run() {
    for (int i = 0; i < 10 ; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//主线程
public class MainThread {
  public static void main(String[] args) { 
    //创建Runnable实现类对象
    MyThreadDemo02 runnable = new MyThreadDemo02();
 
    //创建Thread类的对象,并且该对象构造方法中传递Runnable实现类对象
    Thread thread02 = new Thread(runnable);
 
    //调用Thread对象的start()方法来启动线程
    thread02.start();
 
    for (int i = 0; i < 20 ; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}

方法三:匿名内部类方式

  • 匿名内部类能够简化程序
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//方法三:匿名内部类
public class MainThread {
  public static void main(String[] args) {
    //Thread方式
    new Thread(){
      @Override
      public void run() {
        for (int i = 0; i < 10 ; i++) {
          System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
      }
    }.start();
    //Runnable接口方式
     new Thread(new Runnable() {
      @Override
      public void run() {
        for (int i = 0; i < 10 ; i++) {
          System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
      }
    }).start();
    ////////////////////////////////////////////////
 
    for (int i = 0; i < 20 ; i++) {
      System.out.println(Thread.currentThread().getName()+"-->"+i);
    }
  }
}

线程安全问题

多线程访问共享数据,,且多个线程中对资源有写的操作,就会出现线程安全问题

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作,而无写操作,一般来说,这个全局变量是线程安全的;若有多个线程同时执行写操作,一般都需要考虑线程同步, 否则的话就可能影响线程安全。

解决线程安全问题采用线程同步机制,主要有以下三种方式:

  • 同步代码块
  • 同步方法
  • 锁机制

同步代码块

同步代码块:synchronized 关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。

  • 格式:synchronized(锁对象){ //访问共享数据的代码 }
  • 锁对象可以是任意类型
  • 多个线程对象要使用同一把锁
  • 锁对象是将同步代码块锁住,只让线程在同步代码块中执行
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class SafeRunnableDemo implements Runnable {
  private int ticket = 100;
 
  //同步代码块
  //创建锁对象
  Object lock = new Object();
 
  @Override
  public void run() {
    while (true){
      //锁住同步代码块
      synchronized (lock){
        if (ticket > 0) {
          System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
          ticket--;
        }
      }
    }
  }
}

同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着

  • 格式:修饰符 synchronized 返回值类型 方法名(参数列表) { //访问共享数据的代码 }
  • 把共享了同步数据的代码抽取出来,放入同步方法中
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class SafeRunnableDemo implements Runnable {
  private int ticket = 100;
 
  //同步方法
  //定义一个同步方法
  public synchronized void lock(){
    //同步方法锁住代码块
    if (ticket > 0) {
      System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
      ticket--;
    }
  }
 
  //重写run并使用同步方法
  @Override
  public void run() {
    while (true){
      lock();
    }
  }
}

Lock锁

Lock提供了比synchronized更广泛的锁操作

  • 在Lock接口中 void lock() 获取锁,void unlock() 释放锁
  • 需要在成员位置处创建ReentraLock对象,在共享数据代码块之前调用方法lock()获取锁,在之后用unlock()方法释放锁
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class SafeRunnableDemo implements Runnable {
  private int ticket = 100;
 
  //Lock锁方法
  //创建ReentrantLock对象
  Lock lock = new ReentrantLock();
  @Override
  public void run() {
    while (true){
      //在可能出现问题的代码块之前用lock()方法
      lock.lock();
      if (ticket > 0) {
        System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
        ticket--;
      }
      //在可能出现问题的代码块之后用unlock()方法
      lock.unlock();
    }
  }
}

线程机制

  • NEW(新建):线程刚被创建,但是并未启动。还没调用start()方法。
  • Runnable(可运行):线程可以在java虚拟机中运行的状态,可能正在运行自己代码,也可能没有,这取决于操作系统处理器。
  • Blocked(锁阻塞):当一个线程试图获取一个对象锁,而该对象锁被其他的线程持有,则该线程进入Blocked状态;当该线程持有锁时,该线程将变成Runnable状态。
  • Waiting(无限等待):一个线程在等待另一个线程执行一个(唤醒)动作时,该线程进入Waiting状态。进入这个状态后是不能自动唤醒的,必须等待另一个线程调用notify()或者notifyAll()方法才能够唤醒。
  • Timed Waiting(计时等待):同waiting状态,有几个方法有超时参数,调用他们将进入Timed Waiting状态。这一状态 将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep()、Object.wait()。
  • Teminated(被终止):因为run方法正常退出而死亡,或者因为没有捕获的异常终止了run方法而死亡。

一个调用了某个对象的 Object.wait() 方法的线程会等待另一个线程调用此对象Object.notify()方法 或 Object.notifyAll()方法。

其实waiting状态并不是一个线程的操作,它体现的是多个线程间的通信,可以理解为多个线程之间的协作关系, 多个线程会争取锁,同时相互之间又存在协作关系。

当多个线程协作时,比如A,B线程,如果A线程在Runnable(可运行)状态中调用了wait()方法那么A线程就进入 了Waiting(无限等待)状态,同时失去了同步锁。假如这个时候B线程获取到了同步锁,在运行状态中调用了 notify()方法,那么就会将无限等待的A线程唤醒。注意是唤醒,如果获取到锁对象,那么A线程唤醒后就进入 Runnable(可运行)状态;如果没有获取锁对象,那么就进入到Blocked(锁阻塞状态)。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class WaitAndSleep {
  public static void main(String[] args) {
    //创建锁对象
    Object lock = new Object();
 
    //匿名内部类创建线程1
    new Thread(){
      @Override
      public void run() {
        System.out.println(Thread.currentThread().getName()+"需要买票");
        //用同步代码块包裹
        synchronized (lock){
          try {
            //lock.wait(5000);//到5秒自动醒来
            lock.wait();//进入无限等待,需要唤醒
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        System.out.println(Thread.currentThread().getName()+"买到了票");
      }
    }.start();
 
    //匿名内部类创建线程2
    new Thread(){
      @Override
      public void run() {
        try {
          Thread.sleep(5000);//等待5秒
          System.out.println(Thread.currentThread().getName()+"出票了");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        //用同步代码块包裹
        synchronized (lock){
          lock.notify();//如果有多个线程等待,随机唤醒一个
          //lock.notifyAll();//唤醒所有等待的线程
        }
      }
    }.start();
  }
}

线程池

当在系统中用到了很多的线程,大量的启动和结束动作会导致系统的性能变卡,响应变慢,采用线程池可以解决这个问题。线程池就相当于一个容器(如同ArrayList),执行的任务放入线程池中,多出来的任务就等待线程池中的任务执行完再放入。

  • 使用线程池的工厂类 Executors 里的静态方法 newFixedThreadPool 生产指定线程数量的线程池,返回为ExecutorService接口
  • 创建一个类实现Runnable接口,重写run方法,设置线程任务
  • 调用ExecutorService中的submit方法,传递线程任务,开启线程
  • 销毁线程池:ExecutorService中的shutdown方法
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
//线程池
public class ThreadPoolMain {
  public static void main(String[] args) {
    //使用线程池的工厂类 Executors里的静态方法 newFixedThreadPool
    // 生产指定线程数量的线程池,返回为ExecutorService接口
    ExecutorService es = Executors.newFixedThreadPool(2);
 
    //调用ExecutorService中的submit方法,传递线程任务,开启线程
    es.submit(new ThreadPoolDemo01());
  }
}
 
//////////////////////////////////////////////////////
 
//创建一个类实现Runnable接口,重写run方法,设置线程任务
public class ThreadPoolDemo01 implements Runnable{
  @Override
  public void run() {
    ...
  }
}

以上就是JAVA多线程知识汇总的详细内容,更多关于JAVA多线程的资料请关注服务器之家其它相关文章!

原文链接:https://www.cnblogs.com/geqianLee/p/13268370.html

延伸 · 阅读

精彩推荐