Java基础学习04--进程与线程

首先介绍进程与线程的基本概念

1.进程与线程

进程：正在运行的程序，是系统进行资源分配的基本单位。

线程：线程可以称为轻量级进程，它进程中的一条执行路径，也是CPU的基本调度单位。

一个进程由一个或多个线程组成，彼此间完成不同的工作。多个线程同时工作，称为多线程。

 

2.进程与线程的区别：

(1)进程是操作系统分配资源的基本单位，线程是CPU调度的基本单位。

(2)一个程序运行至少有一个进程

(3)一个进程可以包含多个线程，但至少有一个线程。

(4)进程间不能共享数据段地址，但同进程的线程之间可以。

 

3.线程的组成

(1)CPU时间片：操作系统会为每个线程分配执行时间

(2)运行数据：

堆内存：存储线程使用的对象，多个线程可以共享堆中对象。

栈内存：存储线程使用的局部变量，每个线程都拥有独立的栈。

(3)线程的逻辑代码

 

4.线程的特点

(1)线程抢占执行。

(2)并发执行，单核CPU中，是顺序执行(线程切换)。

 

5.创建线程的四种方式

(1)继承Thread类

(2)实现Runnable接口

(3)实现Callable接口

(4)使用线程池

package com.example.concurrency;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
//第一种：继承Thread类
class MyThread extends Thread {
    public void run() {
        System.out.println("线程调用");
    }
}

//第二种，实现Runnable接口
class MyRunnable implements Runnable {
    private Boolean tag = true;

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int i = 0;
        while (tag) {
            System.out.println("线程调用:" + i++);
        }
    }

    public void stop() {
        this.tag = false;
    }
}

//第三种：实现Callable接口
class MyCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("线程调用，返回123");
        return 123;
    }

}

//创建线程的四种方式
public class demo05 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 方式一：继承Thread类
        MyThread thread3 = new MyThread();
        thread3.start();
        
        // 方式二：实现Runnable接口
        MyRunnable instance = new MyRunnable();
        Thread thread = new Thread(instance);
        thread.start();

        // 方式三-实现Callable接口：
        MyCallable mc = new MyCallable();
        FutureTask<Integer> ft = new FutureTask<Integer>(mc);
        Thread thread2 = new Thread(ft);
        thread2.start();

        // 方式四-使用线程池：
        ExecutorService ser = Executors.newFixedThreadPool(1);// 线程池
        Future<Integer> ft2 = ser.submit(mc);// 执行线程
        Integer result = ft2.get();// 获取结果
        ser.shutdown();// 关闭
    }
}

 

5.1线程池使用的详细代码：

public class demo01 {
    //线程池的使用
    public static void main(String[] args) {
        // 1创建线程池

        // 1.1 创建固定数量的线程池
        // ExecutorService eService = Executors.newFixedThreadPool(4);
        // 1.2创建不固定数量的线程池，缓存线程池
        ExecutorService eService = Executors.newCachedThreadPool();

        //1.3创建单线程的线程池
        //Executors.newSingleThreadExecutor();
        
        //1.4创建调度线程池
        //Executors.newScheduledThreadPool(4);
        
        // 2.创建任务
        Runnable runnable = new Runnable() {
            private int ticket = 500;

            @Override
            public void run() {
                for (int i = 500; i >= 0; i--) {
                    saleTicket();
                }
            }

            public synchronized void saleTicket() {
                if (ticket > 0) {
                    ticket--;
                    System.out.println(Thread.currentThread().getName() + "卖了1张票，库存还有" + this.ticket + "张票");
                }
            }
        };

        // 3.启动线程池
        for (int i = 0; i < 4; i++) {
            eService.submit(runnable);
        }

        // 4.关闭线程池
        eService.shutdown();// 等待线程执行完毕
        // eService.shutdownNow();//不等待线程执行完毕，直接关闭
    }
}

 

5.2使用Callable实现1-100的和

public class demo02 {
    //功能需求：使用Callable实现1-100的和
    public static void main(String[] args) {        
        //1.创建Callable对象
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for(int i=1;i<=100;i++) {
                    sum += i;
                }
                return sum;
            }            
        };
        
        //2.将Callable对象，转换成可运行的任务
        FutureTask<Integer> task = new FutureTask<>(callable);
        
        //3.将任务对象传递给Thread对象
        Thread thread = new Thread(task);
        
        //4.启动线程
        thread.start();        
        
        //5.获得结果
        Integer result;
        try {
            result = task.get();
            System.out.println("计算结果为："+result);    
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }            
    }
}

 

5.3使用线程池计算1-100的和

public class demo03 {
    //使用线程池，计算1-100的和
    public static void main(String[] args) {
        //1.创建单线程的线程池
        ExecutorService exectorService = Executors.newSingleThreadExecutor();
        
        //2.创建Callable对象
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for(int i=1;i<=100;i++) {
                    sum += i;
                }
                return sum;
            }            
        };
        
        //3.将callable对象送给线程池
        Future<Integer> future = exectorService.submit(callable);
        
        //4.获取计算结果
        try {            
            Integer result = future.get();
            System.out.println("计算结果为："+result);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        //5.关闭线程池
        exectorService.shutdown();
    }
}