Java中的多线程

最新推荐文章于 2023-10-10 12:40:22 发布

Monday_@@

最新推荐文章于 2023-10-10 12:40:22 发布

阅读量199

点赞数

分类专栏： java基础文章标签：多线程

本文链接：https://blog.csdn.net/weixin_42228950/article/details/90312024

版权

java基础专栏收录该内容

54 篇文章 0 订阅

订阅专栏

学习多线程的话，首先我们要弄明白是什么是进程，什么是线程？

一、进程和线程

进程是资源分配的最小单位，线程是程序执行的最小单位。通常在一个程序中包含至少一个进程，在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义；线程可以共享进程中的所有资源；进程如下图所示：

线程的生命周期：

New(新生)，Runnable(可运行/就绪)（Runnable与Running）；blocked(被阻塞)；Dead(死亡)。

新建：从新建一个线程对象到程序start() 这个线程之间的状态，都是新建状态；

就绪：线程对象调用start()方法后，就处于就绪状态，等到JVM里的线程调度器的调度；

运行：就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态，运行状态的线程可变为就绪、阻塞及死亡三种状态。

等待/阻塞/睡眠：在一个线程执行了sleep（睡眠）、suspend（挂起）等方法后会失去所占有的资源，从而进入阻塞状态，在睡眠结束后可重新进入就绪状态。

终止：run（）方法完成后或发生其他终止条件时就会切换到终止状态。

进程和线程的区别：

1、资源共享：同一进程中的线程，在该进程中的资源共享；

2、空间独立：不同进程之间空间是独立的，而同一进程中的线程共享该进程的空间；

3、都可以并发；

4、线程是处理器调度的基本单位，但是进程不是。

二、线程的创建方式

1、继承Thread类创建线程：

package com.lzw.demo;

public class MyThread extends Thread{

	@Override
	public void run() {
		// 重写run方法
		super.run();
	}
	
	public static void main(String[] args) {
		//创建线程并启动
		MyThread myThread = new MyThread();
		myThread.start();
	}
}

2、实现Runnable接口创建线程：具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

package com.lzw.demo;

public class MyThread2 implements Runnable {

	@Override
	public void run() {

	}

	public static void main(String[] args) {
		//创建线程 启动线程
		MyThread2 myThread2 = new MyThread2();
		Thread thread = new Thread(myThread2);
		thread.start();
		//new Thread(myThread2).start();
	}

}

3、使用Callable和Future创建线程

package com.lzw.demo;

import java.util.concurrent.Callable;
/**
 * 实现Callable创建线程
 * @author Administrator
 * @version 创建时间：2019年5月19日 下午4:49:00
 * @param <V>
 */
public class MyThread3<V> implements Callable<V> {

	@Override
	public V call() throws Exception {
		return null;
	}
	
	public static void main(String[] args) {
		MyThread3<Object> myThread3 = new MyThread3<>();
		try {
			Object call = myThread3.call();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

package com.lzw.demo;

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

/**
 * @author lzw
 * @Date 2019年5月20日
 */
public class MyThread {


	
	public static void main(String[] args) {
		 Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
	        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

	        for (int i = 0; i < 100; i++) {
	            System.out.println(Thread.currentThread().getName() + " " + i);
	            if (i == 30) {
	                Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
	                thread.start();                      //线程进入到就绪状态
	            }
	        }

	        System.out.println("主线程for循环执行完毕..");
	        
	        try {
	            int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
	            System.out.println("sum = " + sum);
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        } catch (ExecutionException e) {
	            e.printStackTrace();
	        }

	    }

}


class MyCallable implements Callable<Integer> {
    private int i = 0;

    // 与run()方法不同的是，call()方法具有返回值
    @Override
    public Integer call() {
        int sum = 0;
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            sum += i;
        }
        return sum;
    }

}

三种创建方式的区别：

1、通过Thread的源码可以看出，Thread是实现了Runnable接口。

2、实现Runnable接口可以避免Java单继承特性而带来的局限；增强程序的健壮性，代码能够被多个线程共享，代码与数据是独立的；适合多个相同程序代码的线程去处理同一资源的情况。

3、继承Thread类和实现Runnable方法启动线程都是使用start方法，然后JVM虚拟机将此线程放到就绪队列中，如果有处理机可用，则执行run方法。

4、实现Callable接口要实现call方法，并且线程执行完毕后会有返回值；其他的两种都是重写run方法，没有返回值；call方法可以抛出异常，run方法不可以。

5、最好用的还是实现Runnable接口来创建线程、