什么是线程?

一、概述

        现代操作系统,都可以执行多任务。多任务就是用试运行多个任务。例如 QQ可以同时对消息的收发。CPU执行代码都是一条一条顺序执行的,但是,即使是单核CPU,也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行。

二、进程与线程

    1.1 什么是程序?

        程序是含有指令和数据的文件,被存储在磁盘或其他的数据存储设备中,可以理解为程序是包含静态代码的文件。

    1.2 什么是进程?

         进程是程序的一次执行过程,是系统运行程序的基本单位。在windows系统中,每一个正在执行的exe文件或后台服务,都是一个进程,由操作系统统一管理并分配资源,因此进程是动态的。

       操作系统运行一个程序,即是一个进程从创建、运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令的执行着。同时,每个进程还占有某些系统资源如CPU时间、内存空间、文件、输入输出设备的使用权。

    1.3 什么是线程?

       某些进程内部还需要同时执行多个子任务。而这些子任务我们就称之为线程,线程是进程划分成的更小的运行单位。

      进程和线程的关系就是: 

       一个进程可以包含一个或者多个线程,但至少会有一个主线程。

       线程是比进程更小的执行单位(CPU的最小执行单位)。一个进程在其执行的过程中可以产生多个线程。与进程不同的是:同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或者是在各个线程之间作切换工作时,负担要比进程小的多。

     1.4 进程和线程的区别

  •  根本区别:进程是操作系统资源分配的基本单位,而线程是处理器任务调度和执行的基本单位;
  • 资源开销:每个进程都有独立的代码副本和数据空间,进程之间的切换,资源开销较大;线程可以看作轻量级的进程,每个线程都有自己独立的运行栈和程序计数器,线程之间切换,资源开销较小;
  • 包含关系:一个进程内包含多个线程,在执行过程,线程的执行不是线性串行的,而是多条先线程并行共同完成;
  • 内存分配:同一个进程内的所有线程共享本进程的内存空间和资源;进程之间的内存空间和资源相互独立;
  • 影响关系:一个进程崩溃后,在保护模式下不会对其他进程产生影响;一个线程崩溃,会导致整个进程退出。所以多进程要比多线程健壮;
  • 执行过程:每个独立的进程都有程序运行的入口和出口。但是线程不能独立执行,必须依存于应用程序(进程)中,由应用程序提供多个线程执行控制。

  三、线程的基本概念

       一、单线程

         单线程就是进程中只有一个线程。单线程在程序执行时,所走的程序路径按照连续顺序排下来,前面的必须处理好,后面的才会执行。

public class SingleThread {
  	public static void main(String[] args) {
          for (int i = 0; i < 10000; i++) {
              System.out.print(i + " ");
          }
  	}
}

          二、多线程

          由一个以上的线程组成的程序称为多线程程序。Java中,一定是从主线程开始执行(main方法)。然后在主线程的某个位置创建并启动新的线程。

public class MultiThread {
	public static void main(String[] args) {
        // 创建2个线程
		Thread t1 = new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 10000; i++) {
					System.out.println("线程1:" + i + " ");
				}
			}
		});
		Thread t2 = new Thread(new Runnable() {

			@Override
			public void run() {
				for (int i = 0; i < 10000; i++) {
					System.out.println("线程2:" + i + " ");
				}
			}
		});

        // 启动2个线程
		t1.start();
		t2.start();
	}
}

     四、线程的创建与启动

     通过创建Thread实例,完成线程的创建。

  • 线程的内部实现可以通过继承Thread类,实现Runnable接口等方式进行封装。
  • 通过调用Thread实例的start()方法(是一个native本地方法)启动新线程。
    public class Main {
        public static void main(String[] args) {
            // Step1: main主线程执行输出
            System.out.println("main start...");
            
            // Step2: main主线程,创建子线程sub,输出字母A-Z
            Thread sub = new Thread() {
                // Step4:子线程被执行时,自动调用run()方法
                public void run() {
                    for(char c='A';c<='Z';c++){
                        System.out.println("子线程:" + c);
                    }
                }
            };
            
            // Step3: main主线程,启动子线程sub
            sub.start();
            
            // Step4: main主线程执行输出字母的ASCII码
            for(int c ='a';c<='z';c++){
                System.out.println("main线程:" + c);
            }
            System.out.println("main end...");
        }
    }

  五、线程的创建方式

     5.1、方式一:继承java.lang.Thread类(线程子类)

// 线程子类
public class SubThread extends Thread {
       public void run() {
           for (int i = 0; i < 10000; i++) {
               System.out.println("子线程" + i + " ");
           }
       }
}

// 主线程main
public class MultiThread {
       public static void main(String[] args) {
            //创建并启动子线程
           SubThread thd = new SubThread();
           thd.start();
           
           //主线程继续同时向下执行
           for (int i = 0; i < 10000; i++) {
               System.out.println("主线程" + i + " ");
           }
       }
}

5.2、方式二:实现java.lang.Runnable接口(线程执行类)

   

// 线程执行类
public class SubThread implements Runnable {
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("子线程" + i + " ");
        }
    }
}

// 主线程 main
public class MultiThread {
    public static void main(String[] args) {
        //创建并启动子线程
        Thread t = new Thread(new SubThread());
        t.start(); 

        //主线程继续同时向下执行
        for (int i = 0; i < 10000; i++) {
            System.out.println("主线程" + i + " ");
        }
    }
}

5.3、方法三:实现java.util.concurrent.Callable接口,允许子线程返回结果、抛出异常

// 实现子线程
public class SubThread implements Callable<Integer>{
    private int begin,end;
    public SubThread(int begin,int end){
        this.begin = begin;
        this.end = end;
    }
    @Override
    public Integer call() throws Exception {
        int result = 0;
        for(int i=begin;i<=end;i++){
            result+=i;
        }
        return result;
      }
}

子线程创建并启动

// 子线程封装为FutureTask对象,计算1-100的累加和
SubThread subThread1 = new SubThread(1,100);
FutureTask<Integer> task1 = new FutureTask<>(subThread1);

// 子线程封装为FutureTask对象,计算101-200的累加和
SubThread subThread2 = new SubThread(101,200);
FutureTask<Integer> task2 = new FutureTask<>(subThread2);

// 分别启动两个子线程
new Thread(task1).start();
new Thread(task2).start();

// 分别获取两个子线程的计算结果
int sum1 = task1.get();
int sum2 = task2.get();

// 汇总计算结果
int total = sum1 + sum2;

5.4、方式四、线程池

   线程池,按照配置参数(核心线程数、最大线程数等)创建并管理若干对象。程序中如果需要线程,将一个执行任务传给线程池,线程并不会死亡,而是再次返回线程成为空闲状态,等待执行下一个任务。使用线程持可以更好的提高性能。

// 创建固定大小的线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while (true) {
    // 提交多个执行任务至线程池,并执行
    threadPool.execute(new Runnable() {
        @Override
        public void run() {
             System.out.println("当前运行的线程名为: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    });
}

  • 3
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值