Java多线程之一

最新推荐文章于 2023-11-09 16:17:59 发布

SupWTian

最新推荐文章于 2023-11-09 16:17:59 发布

阅读量679

点赞数

分类专栏： java语言文章标签：多线程 java 操作系统并发线程

本文链接：https://blog.csdn.net/JerryBurning/article/details/47958325

版权

java语言专栏收录该内容

21 篇文章 0 订阅

订阅专栏

1、线程的概述
进程定义：“进程是进程实体（PCB、程序段、数据段）的运行过程，是系统进行资源分配和调度的一个独立单元”。引入进程的目的，是为了使多道程序并发执行，以提高资源利用率和系统吞吐量；而引入线程的目的是为了减小程序在并发执行时所付出的时空开销，提高操作系统的并发性能。
进程是处于运行过程中的程序，是系统进行资源分配和调度的一个独立单元。一般而言具有以下特征：

独立性：进程是系统中独立存在的实体，可以拥有自己的资源，每一个进程都拥有自己独立的地址空间。
动态性：动态性这就是进程和程序的主要区别。进程具有自己的生命周期和各种不同的状态，这些概念在程序中是不具有的。
并发性：多个进程可以在单处理器上并发执行，多个进程间互不干扰。

进程和线程的区别：

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动。在传统的操作系统中，进程是系统进行资源分配和调度的一个基本单元，在引入线程的操作系统中，线程是独立调度的基本单元，进程是资源拥有的基本单元。
线程是CPU调度的基本单位,它是比进程更小的能独立运行的基本单位.
线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但同一个进程的其他的线程共享进程所拥有的全部资源。
一个线程可以创建和撤销另一个线程，同一个进程中的多个线程之间可以并发执行。

本质区别：进程之间拥有独立的地址空间，不共享地址空间；而线程是共享进程的地址空间

在多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待资源而进入空闲状态。多个线程共享堆内存(heap memory)，因此创建多个线程去执行一些任务会比创建多个进程更好。

在实际的应用中，多线程是非常有用的，一个浏览器必须能同时下载多个图片；一个Web服务器必须能同时响应多个用户的请求；Java虚拟机在后台进行的垃圾回收等等。

2、进程的创建和启动
java使用Thread类代表进程，所有的进程对象都必须是Thread类和其子类的实例。每条线程的作用是完成一定的任务，实际上就是执行一段程序流。
创建线程的三种方式：
方式一：继承Thread类创建线程，继承Thread类，从写线程执行体Run()方法。

public class MyThread extends Thread{
    private int i;
    @Override
    public void run() {
        for(;i<100;i++){
            //线程继承Thread类时，可以直接调用getName()方法来返回当前线程的名
            //如果想获取当前线程，直接使用this即可
            //Thread的getName()返回当前线程的名字
            System.out.println(Thread.currentThread().getName()+" "+i);         
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Thread myThread1 = new MyThread();    
                Thread myThread2 = new MyThread();     
                myThread1.start();                     
                myThread2.start(); 
            }
        }
    }
}

方式二：实现Runnable接口创建线程
1、实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体；
2、创建Runnable实现类的实例，并以此实例作为Thread的构造函数的参数来创建线程。

public class MyRunnable implements Runnable {
    private int i=0;
    @Override
    public void run() {
        for(;i<100;i++){
            //当前线程类实现Runnable接口时，如果想获取当前线程，可以使用Thread.currentThread()方法
            //Thread的currentThread()返回当前线程
            //可以被多个线程共享
            System.out.println(Thread.currentThread().getName()+" "+i);         
        }       
    }
}


public class ThreadTest {

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
                Runnable myRunnable = new MyRunnable(); // 创建一个Runnable实现类的对象
                Thread thread1 = new Thread(myRunnable); // 将myRunnable作为Thread target创建新的线程
                Thread thread2 = new Thread(myRunnable);
                thread1.start(); // 调用start()方法使得线程进入就绪状态
                thread2.start();
            }
        }
    }
}

方式三：.使用Callable和Future接口创建线程。
具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象创建实例，并以此实例作为Thread的构造函数的参数来创建线程。FutureTask实现了Callable接口和Runnable接口。

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


public class ThreadTest {
    public static void main(String[] args) {
        // 创建MyCallable对象
        Callable<Integer> myCallable = new MyCallable();  
        //使用FutureTask来包装MyCallable对象  
        FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); 
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 30) {
            //FutureTask对象作为Thread对象的target创建新的线程
                Thread thread = new Thread(ft);   
                thread.start();
            }
        }
        System.out.println("主线程for循环执行完毕..");        
        try {
            //取得新创建的新线程中的call()方法返回的结果
            int sum = ft.get();            
            System.out.println("sum = " + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}