java多线程理解及实现

其实多线程也很好理解，就好比我们坐高铁、飞机过安检一样，过安检的时候一个入口只有一个安检口，而多线程就是为安检开启了多个安检口，话不多说贴代码

线程实现的三种方式：

一、继承Thread类创建线程类

1、定义Thread子类，重写run()方法，把需要做线程操作的类容放入该方法体中。

2、创建Thread子类的实例，在实例中调用线程对象的start()启动线程方法，此方法也是代表线程数量的方法，需要启动多个线程时，只需要调用多次则以。

package com.thread;
public class FirstThreadTest extends Thread{
  int i = 0;
  //重写run方法，run方法的方法体就是现场执行体
  public void run(){
    for(;i<100;i++){
      System.out.println(getName()+" "+i);
    }
  }
  public static void main(String[] args){
    for(int i = 0;i< 100;i++){
      System.out.println(Thread.currentThread().getName()+" :"+i);
      if(i==20){
        new FirstThreadTest().start();
        new FirstThreadTest().start();      }
    }
  }}

上述代码中Thread.currentThread()方法返回当前正在执行的线程对象，getName()方法返回线程名称。

二、通过Runnable接口创建线程类，这也是常用的一种

1、定义runnable接口实现类，并重写run()方法，此方法跟继承Thread类中的run是一样的

2、创建实现类的实例，并在实例中创建Thread对象，该对象也是代表线程数量的对象，启动多个线程只需要多次调用对象的start()方法则以。

package com.thread;
public class RunnableThreadTest implements Runnable
{
  private int i;
  public void run()
  {
     for(i = 0;i <100;i++){
       System.out.println(Thread.currentThread().getName()+" "+i);
     }
  }
  public static void main(String[] args){
    for(int i = 0;i < 100;i++){
      System.out.println(Thread.currentThread().getName()+" "+i);
      if(i==20){
        RunnableThreadTest rtt = new RunnableThreadTest();
        new Thread(rtt,"新线程1").start();
        new Thread(rtt,"新线程2").start();
      }
    }
  }
}

三、通过线程池实现多线程，这个是做常用的也是最实用的

1、通过ExecutorService来管理线程池，并且初始化线程数量

2、定义队列来存放线程池

3、循环判断线程是否执行还是睡眠

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

public class TestThread {

    // 首先初始化ExecutorService线程池，用来管理多线程，设置线程数量
    private static ExecutorService pool = Executors.newFixedThreadPool(50);

    // 定义Queue队列，用来存放线程池，Runnable就是线程对象
    private static Queue<Runnable> queue = new ConcurrentLinkedDeque<>();

    // 类加载执行多线程
    static {
        (new TestThread()).new ThreadPoolInvoke().start();
    }

    private  class ThreadPoolInvoke extends Thread{
        @Override
        public void run() {
            // 死循环一直判断队列
            while (true) {
                try {
                    // 如果为空，线程睡眠3秒
                    if (queue.isEmpty()) {
                        Thread.sleep(1000 * 3);
                    }
                    // 如果不为空则执行任务，定义excute方法
                    excute();
                } catch (Exception e) {
                    // TODO: handle exception
                }

            }
        }

    }
    /**
     * 设置线程到队列方法
     * @param runnable
     */
    public static void setTask(Runnable runnable) {
        queue.add(runnable);
    }

    /**
     * 执行线程任务
     */
    private void excute() {
        //为了确保线程安全，这里可以设置同步锁，this表示当前进入者
        //synchronized (this) {
        // 获取queue队列size
        int curLen = queue.size();
        for (int i = 0; i < curLen; i++) {
            // poll 方法表示从队列中删除第一个元素
            Runnable item = queue.poll();
            // 然后把对象交给多线程处理
            pool.execute(item);
        }
        //}
    }
}

好了，今天的多线程分享就到这，是否学会了呢？

原文地址：https://www.cnblogs.com/yonim/p/11417598.html