JAVA多线程知识汇总

线程概念

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

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

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

线程调度：

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

创建多线程

方法一：创建Thread类的子类

创建Thread类的子类，并重写该类的run()方法，设置线程任务。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

									//方法一：

									//定义Thread类的子类，并重写该类的run()方法

									public class MyThreadDemo01 extends Thread {

									  @Override

									  public void run() {

									    for (int i = 0; i < 20 ; i++) {

									      System.out.println(getName()+"-->"+i);

									    }

									  }

									}

									//主线程

									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()方法来启动线程

									//方法二：

									//定义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);

									    }

									  }

									}

									//主线程

									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);

									    }

									  }

									}

方法三：匿名内部类方式

匿名内部类能够简化程序

									//方法三：匿名内部类

									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(锁对象){ //访问共享数据的代码 }
锁对象可以是任意类型
多个线程对象要使用同一把锁
锁对象是将同步代码块锁住，只让线程在同步代码块中执行

									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 返回值类型方法名(参数列表) { //访问共享数据的代码 }
把共享了同步数据的代码抽取出来，放入同步方法中

									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()方法释放锁

									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（锁阻塞状态）。

									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方法

									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

相关文章

热门资讯