java 多线程实现四种方式解析Thread,Runnable,Callable,ServiceExcutor,Synchronized ,ReentrantLock

Wesley13
• 阅读 633

1.Thread实现:

import java.util.Date;
import java.text.SimpleDateFormat;

public class MyThread extends Thread{
    @Override
    public   void run(){

        SimpleDateFormat strf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
        String d = strf.format(new Date());// new Date()为获取当前系统时间
        System.out.println(d+"  "+Thread.currentThread().getName());

    }

    public static void main(String[] args) {
//        MyThread myThread  = new MyThread();
        for (int i = 0; i < 10; i++) {
            new MyThread().start();

        }

    }
}

2020-01-23 21:15:54 Thread-1
2020-01-23 21:15:54 Thread-8
2020-01-23 21:15:54 Thread-7
2020-01-23 21:15:54 Thread-5
2020-01-23 21:15:54 Thread-4
2020-01-23 21:15:54 Thread-3
2020-01-23 21:15:54 Thread-0
2020-01-23 21:15:54 Thread-2
2020-01-23 21:15:54 Thread-6
2020-01-23 21:15:54 Thread-9

2.Runnable :

class MyRunnable implements Runnable {

    int i =0;
    @Override
    public  void run(){
        System.out.println(Thread.currentThread().getName()+"  "+ i++);
    }


    public static void main(String[] args) {
        Runnable  implRunnable = new MyRunnable();
//        Thread thread = new Thread(implRunnable);
        for (int i = 1; i <5 ; i++) {
//            new Thread(implRunnable).start();  // int i全局线程操作共享
            new Thread(new MyRunnable()).start();  //  int  i 变量线程操作独立,
        }

    }
}

3. Callable:

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

public class MyCallable implements Callable<Object> {

    @Override
    public Object call() throws Exception{
        int  result =0 ;
        for (int j = 0; j <8 ; j++) {
            result +=j;
        }
        System.out.println(Thread.currentThread().getName());
       return result;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        for (int i = 0; i <5 ; i++) {
            Callable<Object> callable  = new MyCallable() ;
            FutureTask<Object> futureTask = new FutureTask<Object>(callable);
           new Thread(futureTask).start();
           System.out.println(futureTask.get());

        }

    }
    
}

Thread-0
28
Thread-1
28
Thread-2
28
Thread-3
28
Thread-4
28

4.ThreadPool使用同步原语,重入锁,同步代码块,代码类,或者对象,对基本数据类型无效:

import java.util.concurrent.locks.ReentrantLock;

public class SynchronizedTest implements Runnable {
    private  int i =10;
    // synchronized   mean  block one   thread opt some var  util other th have fish some operation ;
    @Override
    public   void run() {
        //或者同步代码块 Integer Object  ,int是基本数据类型,不是object;
        //synchronized(SychronizeTest.class) {
        ReentrantLock  RLock = new ReentrantLock();
        RLock.lock();
            if (i >= 1) {

                try {
                    Thread.sleep(100);
                    i--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "  " + i);
            } else {
                System.out.println("库存不足");
            }
         RLock.unlock();
        //}
    }
    public static void main(String[] args)  throws Exception{
        Runnable runnable  =  new SynchronizedTest();
        for (int i = 0; i < 20; i++) {
            new Thread(runnable).start();

        }
        Thread.sleep(3000);

    }
}
点赞
收藏
评论区
推荐文章
待兔 待兔
3个月前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
Wesley13 Wesley13
3年前
java多线程和异步回调
   在实际开发过程中遇到的多线程情况不多,但是在生产环境中多线程是最基本的情况,java面试时也会考到,所以看看多线程的知识还是很有必要的。 Thread,Runnable,Callable,Future,FutureTask,Executors这是java常见的接口和类。  thread.run():线程具体要执行的代码,thread.jo
Wesley13 Wesley13
3年前
java多线程实现的三种方式
JAVA多线程实现方式主要有三种:继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值,只有最后一种是带返回值的。1、继承Thread类实现多线程继承Thread类的方法尽管被我列为一种多线程实现方式,但Thread本质上也是实现
浪人 浪人
3年前
一篇文章弄懂Java多线程基础和Java内存模型
文章目录一、多线程的生命周期及五种基本状态二、Java多线程的创建及启动1.继承Thread类,重写该类的run()方法2.通过实现Runnable接口创建线程类3.通过Callable和Future接口创建线程三、Java内存模型概念四、内存间的交互操作五、volatile和synchronized的
Wesley13 Wesley13
3年前
Java面试系列
实现多线程的方式继承Thread类,重写run方法,调用start方法启动线程实现Runnable接口,重写run方法,调用start方法启动线程实现Callable接口,重写call方法,并用FutureTask包装,在newThread中传入FutureTask,然后调用start方
Wesley13 Wesley13
3年前
Java多线程基础
(1)传统使用类Thread和接口Runnable实现 1\.在Thread子类覆盖的run方法中编写运行代码方式一 newThread(){@Overridepublicvoidrun(){while(true){try{Thread.sleep(2
Wesley13 Wesley13
3年前
JAVA多线程实现的四种方式
Java(https://www.oschina.net/action/GoToLink?urlhttp%3A%2F%2Flib.csdn.net%2Fbase%2Fjavaee)多线程实现方式主要有四种:继承Thread类实现Runnable接口、实现Callable接口通过FutureTask包装
Wesley13 Wesley13
3年前
Java多线程学习笔记
Java中创建多线程的三种方法1、继承Thread类创建线程2、实现Runnable接口创建线程3、使用Callable和Future创建线程\
Wesley13 Wesley13
3年前
Java多线程 简记
1、实现多线程方法继承Thread类或者实现Runnable接口2、Thread 和Runnable区别实现Runnable接口比继承Thread类所具有的优势:1):适合多个相同的程序代码的线程去处理同一个资源2):可以避免java中的单继承的限制3):增加程序的健壮性,代码可以被多个
Wesley13 Wesley13
3年前
Java并发编程指南
  多线程是实现并发机制的一种有效手段。在Java中实现多线程有两种手段,一种是继承Thread类,另一种就是实现Runnable/Callable接口。  java.util.concurrent包是专为Java并发编程而设计的包。类图如下:!(https://oscimg.oschina.net/oscnet/29ddbb