标签：image   调用   http   方法   接口   模拟   需要   row   请求   

多线程

进程

每一个应用程序在运行时，都会产生至少一个进程（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()才是开启一个新线程，会创建新的栈。

线程的优先级

演示示例：

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基础教程——多线程：创建线程

标签：image   调用   http   方法   接口   模拟   需要   row   请求   

原文地址：https://www.cnblogs.com/tigerlion/p/11179234.html