Java基础教程——多线程:创建线程

Posted tigerlion

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java基础教程——多线程:创建线程相关的知识,希望对你有一定的参考价值。

多线程

进程

每一个应用程序在运行时,都会产生至少一个进程(process)。
进程是操作系统进行“资源分配和调度”的独立单位。

Windows系统的“任务管理器”可以查看系统的进程,通过Ctrl+Shift+Esc组合键可以调出“任务管理器”。

进程具有三个特征:

  • 独立性:进程拥有自己独立的资源,有私有的地址空间。
  • 动态性:程序是静态的指令集合,而进程是活动的指令集合,进程有其生命周期。
  • 并发性:多个进程可以在同一个处理器上并发执行,互不影响。虽然同一时刻只能有一个进程执行,但是多个进程被快速轮换执行(时间片轮换算法),宏观上有同时执行的效果(同一时间段内执行)。

现代的操作系统都支持多进程并发执行。

线程

? 线程(Thread)是执行特定任务的最小单位,是进程的执行单元,也被称为轻量级进程(Lightweight Process)。
? 一个进程至少有一个线程,也可以有多个线程。所谓多线程就是指同一个进程可以同时并发处理多个任务。

? 线程没有系统资源,多个线程共享其所属进程的系统资源,因此多线程运行时,需要处理好资源同步问题。

技术图片

总结:

  • 操作系统可以同时执行多个任务,每个任务是一个进程;
  • 进程可以同时执行多个任务,每个任务是一个线程。

多线程的优点

多线程就是下图这种感觉:

技术图片

对计算机来说,多线程可以提高CPU的利用率。

例如:网络的数据传输速率远低于计算机的处理能力,如果是单线程程序,在下载网络资源时,CPU需要花费大量的空闲时间来等待,而多线程能够利用这些空闲时间完成其他任务。

具体来说:
|--一个浏览器可以在下载的同时打开其他网页;
|--Web服务器可以同时相应多个用户请求;
|--QQ发送文件的时候还能跟其他人继续聊天……

当前线程

Thread.currentThread():获取当前线程
.getName():获取线程名称

public class TestMainThread 
    public static void main(String[] args) 
        // 获得当前运行的线程
        Thread tMain = Thread.currentThread();
        // 线程名称,优先级,线程组
        System.out.println("当前运行的线程是:" + tMain);
        System.out.println("线程名称:" + tMain.getName());
    

当前运行的线程是:Thread[main,5,main]
线程名称:main


创建线程

方法1:继承Thread类

Thread类代表线程,所有的线程对象都是Thread类或其子类的对象。
创建线程的步骤:

  1. 继承Thread类
  2. 重写run()方法(线程执行体)
  3. 创建Thread类的实例对象
  4. 调用start()方法启动线程

可以使用setName(…)为线程设置名字,用getName()获取。
默认情况下,主线程名为main,子线程名为Thread-0、Thread-1等。

public class _11NewThread 
    public static void main(String[] args) 
        Thread t1 = new MyT();
        t1.setName("1");
        t1.start();
        Thread t2 = new MyT();
        t2.setName("   2");
        t2.start();
    

class MyT extends Thread 
    @Override
    public void run() 
        for (int i = 0; i < 100; i++) 
            System.out.println("线程:" + super.getName());
        
    

方法2:实现Runnable接口

Runnable是个接口,实现Runnable接口的类还可以继承其它类,这是比方法1优越的地方。

  1. 实现Runable接口
  2. 重写run()方法
  3. 创建Runable对象
  4. 创建Thread对象
  5. 调用thread.start()方法,启动线程

实际创建的对象还是Thread实例。

public class _12NewThreadRunnable 
    public static void main(String[] args) 
        MyR r1 = new MyR("A");
        Thread t1 = new Thread(r1);
        t1.setName("XXX");
        t1.start();
        MyR r2 = new MyR("  B");
        Thread t2 = new Thread(r2);
        t2.start();
    

class MyR implements Runnable 
    public MyR(String s) 
        this.s = s;
    
    private String s;
    @Override
    public void run() 
        for (int i = 0; i < 100; i++) 
            System.out.println("线程:" + s);
        
    


*方法3:实现Callable接口

使用Callable和FutureTask创建线程——可以获取线程的返回值。这种做法了解即可。

  1. 实现Callable接口的线程,需重写call()方法,有返回值
  2. 需要FutureTask类包装一下Callablle,该类实现了Runable接口
  3. 以Future对象为参数创建线程,调用start()方法启动
  4. 以Futrue对象.get()接收返回值
package ahjava.p06thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
// 实现Callable接口的线程,需重写call()方法,有返回值
// 需要FutureTask类包装一下Callablle,该类实现了Runable接口
// 以Future对象为参数创建线程,调用start()方法启动
// 以Futrue对象.get()接收返回值
public class _13NewThreadCallable 
    public static void main(String[] args) 
        MyCallable _Callable = new MyCallable("A");
        FutureTask<String> _FutureTask = new FutureTask<>(_Callable);
        Thread _Thread = new Thread(_FutureTask);
        _Thread.start();
        try 
            // 模拟等待,此过程可看到子线程在执行
            Thread.sleep(3000);
         catch (InterruptedException e1) 
            e1.printStackTrace();
        
        // 接受子线程的返回值
        try 
            String s = _FutureTask.get();
            System.out.println("子线程的返回值 = " + s);
         catch (InterruptedException | ExecutionException e) 
            e.printStackTrace();
        
    

class MyCallable implements Callable<String> 
    public MyCallable(String s) 
        this.s = s;
    
    private String s;
    @Override
    public String call() throws Exception 
        for (int i = 0; i < 100; i++) 
            System.out.println("线程:" + s);
        
        return "我是子线程,已经执行完毕";
    

start()和run()

调用start()是开启新线程,调用run()是普通方法调用。

方法调用是入栈操作,调用完毕则出栈。
如果直接调用run()方法,则是在原线程中进行方法调用,用的还是之原线程的栈。
调用start()才是开启一个新线程,会创建新的栈。

技术图片


线程的优先级

最高 10 Thread.MAX_PRIORITY
默认 5 Thread.NORM_PRIORITY
最低 1 Thread.MIN_PRIORITY

演示示例:

Thread(Runnable target, String name):为线程直接命名
Thread.currentThread():获取当前线程

public class Priority线程优先级 
    // *可能不太容易看出来
    public static void main(String[] args) 
        MyRu r1 = new MyRu();
        MyRu r2 = new MyRu();
        MyRu r3 = new MyRu();
        Thread t1 = new Thread(r1);
        // 创建时命名
        Thread t2 = new Thread(r2, "   B");
        Thread t3 = new Thread(r3);
        t1.setName("A");
        t3.setName("       C");
        t1.setPriority(Thread.MAX_PRIORITY);
        t3.setPriority(Thread.MIN_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    

class MyRu implements Runnable 
    @Override
    public void run() 
        String sName = Thread.currentThread().getName();
        int sPri = Thread.currentThread().getPriority();
        for (int i = 0; i < 100; i++) 
            System.out.println("线程:" + sName + " 优先级:" + sPri);
        
    

多线程的运行结果是不确定的,运行结果每次不同,可能有些时候看不出不同优先级的区别。

以上是关于Java基础教程——多线程:创建线程的主要内容,如果未能解决你的问题,请参考以下文章

Java基础教程:多线程基础——线程的状态

Java基础教程:多线程基础——线程间的通信

Java基础教程:多线程基础——阻塞队列

Java基础教程——线程池

互联网架构多线程并发编程高级教程(上)

互联网架构多线程并发编程高级教程(下)