一、创建线程的方法有三种：
（1）继承Thread类,重写run方法；
（2）实现Runnable接口，并将对象实例作为参数传递给Thread类的构造方法；
（3）实现callable接口，并实现call方法，并且线程执行完毕后会有返回值。
注意：（1）和（2）都是调用start()方法启动线程的，然后JVM虚拟机将此线程放到就绪队列中，有处理
机可用时，则执行run方法。这两种方法都重写了run方法，但是没有返回值。
（1）继承Thread类,重写run方法；
启动：创建子类对象+对象.start()
缺点：Java只支持单继承，如果我们的类已经从一个类继承，则无法再继承Thread类
package xiancheng_creat;
/**
* Created by Taoyongpan on 2017/5/6.
*
* 模拟龟兔赛跑
* 1、创建多线程（方式一）：继承 Thread + 重写run方法（线程体）
* 2、使用线程：创建子类对象 + 对象.start()方法 线程启动
*/
public class MyThread {
public static void main(String[] args) {
//创建子类对象
Rabbit rab = new Rabbit();
Tortoise tor = new Tortoise();
//调用start方法 ，启动线程。 内部由CPU管控
rab.start(); //不要调用run方法，由内部自己调用。
tor.start();
for(int i=0;i<30;i++)
{
System.out.println("main-->"+i);
}
}
}
class Rabbit extends Thread{
//线程体 一切从run开始
@Override
public void run() {
//线程体
for(int i=0;i<30;i++)
{
System.out.println("兔子跑了"+i+"步");
}
}
}
class Tortoise extends Thread {
@Override
public void run() {
//线程体
for(int i=0;i<30;i++)
{
System.out.println("乌龟跑了"+i+"步");
}
}
}
程序中的@Override是什么意思？
@Override是Java5的元数据，自动加上去的一个标志，告诉你说下面这个方法是从父类/接口 继承过来的，需要你重写一次，这样就可以方便你阅读，也不怕会忘记
@Override是伪代码,表示重写(当然不写也可以),不过写上有如下好处:
1>可以当注释用,方便阅读
2>编译器可以给你验证@Override下面的方法名是否是你父类中所有的,如果没有则报错
比如你如果没写@Override而你下面的方法名又写错了,这时你的编译器是可以通过的(它以为这个方法是你的子类中自己增加的方法)
使用该标记是为了增强程序在编译时候的检查，如果该方法并不是一个覆盖父类的方法，在编译时编译器就会报告错误。
rab.start(); //不要调用run方法，由内部自己调用。
start是 Tread类中的一个方法 ，会自动调用run（）方法：
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
private native void start0();
/**
* If this thread was constructed using a separate
* <code>Runnable</code> run object, then that
* <code>Runnable</code> object's <code>run</code> method is called;
* otherwise, this method does nothing and returns.
* <p>
* Subclasses of <code>Thread</code> should override this method.
*
* @see #start()
* @see #stop()
* @see #Thread(ThreadGroup, Runnable, String)
*/
@Override
public void run() {
if (target != null) {
target.run();
}
}
而该例子中的内部类已经重写了run 方法；
（2）实现Runnable接口，并将对象实例作为参数传递给Thread类的构造方法：
启动：使用静态代理
1)、创建真实角色
2)、创建代理角色
3)、调用start()方法 启动线程
优点：可以同时实现继承，Runnable接口方式更加通用一些。
1、避免单继承的局限性
2、便于共享资源
通过实现Runnable接口实现多线程。
package xiancheng_creat;
/**
* Created by Taoyongpan on 2017/5/6.
*
* 推荐使用Runnable创建线程
* 1、避免单继承的局限性
* 2、便于共享资源
*/
public class MyTread01 {
public static void main(String[] args) {
//1)、创建真实角色
Programmer pro = new Programmer();
//2)、创建代理角色+真实角色引用
Thread proxy = new Thread(pro);
//3)、调用start()方法 启动线程
proxy.start();
for(int i=0;i<100;i++){
System.out.println("一边聊QQ");
}
}
}
/**
* 使用Runnable 创建进程
* 1、类实现Runable接口+重写run()方法
* 2、启动多线程 使用静态代理
* 1)、创建真实角色
* 2)、创建代理角色
* 3)、调用start()方法 启动线程
*/
class Programmer implements Runnable{
@Override
public void run() {
for(int i=0;i<100;i++){
System.out.println("一边敲代码");
}
}
}
package xiancheng_creat;
/**
* Created by Taoyongpan on 2017/5/6.
* 抢票系统
* 方便共享资源
*/
public class MyTread02 implements Runnable {
private int num = 50;
@Override
public void run() {
while(true){
if(num<=0)
{
break;//跳出循环
}
System.out.println(Thread.currentThread().getName()+"抢到了倒数第"+num--+"张。");
}
}
public static void main(String[] args) {
//真实角色
MyTread02 web = new MyTread02();
//代理
Thread t1 = new Thread(web,"t00t");
Thread t2 = new Thread(web,"t11t");
Thread t3 = new Thread(web,"t22t");
//启动线程
t1.start();
t2.start();
t3.start();
}
}
附加：前两种创建线程的区别：
//继承 Tread类
MyThread extends Thread{
@overwrite
public void run(){
业务流程
}
}
public static void main(String[] args){
MyThread mt = new MyTread();
mt.start();
}
//实现Runnable接口
MyThread implements Runnable{
@overwrite
public void run(){
业务流程
}
}
public static void main(String[] args){
MyThread mt = new MyTread();
Thread td = new Thread(mt);
td.start();
}
从代码的角度来说，实现Runnable接口比继承Thread，多了一个步骤，把要干的事塞进了一线程里（可以这么理解）
但是Java是一种单继承语言，用Runnable接口就摆脱了这种缺陷，并且，对于同一个资源的消耗来说，要用Runnable接口，继承Thread类无法处理对相同资源处理的情况，即Runnable的代码，可以被多个线程（Thread实例）共享 。
package xiancheng_creat;
/**
* Created by Taoyongpan on 2017/5/6.
*/
public class MyThread03 extends Thread {
private int ticket = 5; //总票数
private String name; //窗口号
public MyThread03(String name) {
this.name=name;
}
@Override
public void run() {
while(ticket>0){
ticket--;
System.out.println(name+"买了1张票，剩余票数为："+ticket);
}
}
}
class TicketThread {
public static void main(String[] args) {
//创建三个线程来模拟三个售票窗口
MyThread03 mt1 = new MyThread03("窗口1");
MyThread03 mt2 = new MyThread03("窗口2");
MyThread03 mt3 = new MyThread03("窗口3");
mt1.start();
mt2.start();
mt3.start();
}
}
运行结果：
窗口3买了1张票，剩余票数为：4
窗口3买了1张票，剩余票数为：3
窗口3买了1张票，剩余票数为：2
窗口3买了1张票，剩余票数为：1
窗口3买了1张票，剩余票数为：0
窗口1买了1张票，剩余票数为：4
窗口2买了1张票，剩余票数为：4
窗口1买了1张票，剩余票数为：3
窗口2买了1张票，剩余票数为：3
窗口2买了1张票，剩余票数为：2
窗口2买了1张票，剩余票数为：1
窗口2买了1张票，剩余票数为：0
窗口1买了1张票，剩余票数为：2
窗口1买了1张票，剩余票数为：1
窗口1买了1张票，剩余票数为：0
package xiancheng_creat;
/**
* Created by Taoyongpan on 2017/5/6.
* 抢票系统
* 方便共享资源
*/
public class MyThread02 implements Runnable {
private int num = 5;
@Override
public void run() {
while(true){
if(num<=0)
{
break;//跳出循环
}
System.out.println(Thread.currentThread().getName()+"剩余"+num--+"张。");
}
}
public static void main(String[] args) {
//真实角色
MyThread02 web = new MyThread02();
//创建三个线程来模拟三个售票窗口//Thread有种默认的构造方法，可以这样创建线程时给线程起名
Thread t1 = new Thread(web,"窗口1");
Thread t2 = new Thread(web,"窗口2");
Thread t3 = new Thread(web,"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();
}
}
运行结果：
窗口3剩余5张。
窗口2剩余4张。
窗口2剩余1张。
窗口1剩余3张。
窗口3剩余2张。
继承Thread相当于创建了三个进程模拟三个窗口，无法实现资源共享；而实现Runable接口 也是创建三个进程来模拟三个窗口，并且可以实现资源共享，三个线程的总共票数 为五张
如果把实现Runable接口的 创建线程部分改为如下，则和继承Thread类 的效果一样：
public static void main(String[] args) {
MyThreadr mt1 = new MyThreadr();
MyThreadr mt2 = new MyThreadr();
MyThreadr mt3 = new MyThreadr();
//创建三个线程来模拟三个售票窗口
//Thread有种默认的构造方法，可以这样创建线程时给线程起名
Thread td1 = new Thread(mt1,"窗口1");
Thread td2 = new Thread(mt2,"窗口2");
Thread td3 = new Thread(mt3,"窗口3");
td1.start();
td2.start();
td3.start();
}
（3）实现callable接口，并实现call方法，并且线程执行完毕后会有返回值。
Callable 和 Future接口
Callable是类似于Runnable的接口，实现*Callable接口的类和实现Runnable的类都是可被其它线程执行的任务*。
优点：可以返回值，可以抛异常。
缺点：实现繁琐。
步骤：
1、实现Callable接口+重写call方法
2、借助执行调度服务ExecutorService获取Future对象
ExecutorService ser = Executors.newFixedThreadPool(2); Future<Integer> result= ser.submit(tortoise);
3、获取值result
int num = result.get(); get方法返回值是一个泛型
4、停止服务ser.shutdownNow();
完整代码：
package xiancheng_creat;
import java.util.concurrent.*;
/**
* Created by Taoyongpan on 2017/5/6.
* 使用Callable接口方式创建多线程
*/
public class MyThread04 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//1、创建线程
ExecutorService ser = Executors.newFixedThreadPool(2);//开两个线程
Race tortoise = new Race("老乌龟",1000);
Race rabbit = new Race("小兔子",500);
//2、获取Future对象
Future<Integer> result1 = ser.submit(tortoise);
Future<Integer> result2 = ser.submit(rabbit);
Thread.sleep(2000);//2秒
tortoise.setFlag(false);//停止线程体循环 设置flag = false;
rabbit.setFlag(false);
//3、获取值
int num1 = result1.get();
int num2 = result2.get();
System.out.println("乌龟跑了-->"+num1+"步");
System.out.println("兔子跑了-->"+num2+"步");
//4、停止服务
ser.shutdownNow();
}
}
class Race implements Callable<Integer>
{
private String name;//名称
private long time;//延时时间
private boolean flag = true;
private int step = 0;//步
public Race() {
}
public Race(String name) {
super();
this.name = name;
}
public Race(String name, int time) {
super();
this.name = name;
this.time = time;
}
//有返回值了
@Override
public Integer call() throws Exception {
while(flag){
Thread.sleep(time);//延时
step++;
}
return step;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getTime() {
return time;
}
public void setTime(long time) {
this.time = time;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public int getStep() {
return step;
}
public void setStep(int step) {
this.step = step;
}
}
Callable和Runnable有几点不同：
（1）Callable规定的方法是call()，而Runnable规定的方法是run().
（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
（3）call()方法可抛出异常，而run()方法是不能抛出异常的。
（4）运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
相关推荐
结构光CUDA多线程编程在相位单目双目结构光三维重建系统中的应用：高效0.5秒500万像素三维重建技术,结构光CUDA多线程编程在相位单目双目结构光三维重建系统中的应用：高速500万像素三维重建技术,结构光cuda多线程...
结构光CUDA多线程编程在相位单目双目结构光三维重建系统中的应用：高速500万像素三维重建技术,结构光cuda多线程程序开发可用于基于相位的单目或者双目结构光三维重建系统 0.5s500w像素三维重建。 ,核心关键词：结构...
标题中的“GPU加速的锥束三维重建FDK实现”指的是在计算机断层扫描(CT)成像技术中，采用快速傅里叶变换(Fast Divergence Algorithm, FDK)算法并利用图形处理器单元(GPU)的计算能力进行三维图像重建的技术。...
5. 三维重建：将深度图与相机参数结合，使用三角测量法重建三维模型。 在实现阶段，我们需要编写C++代码来实现上述步骤，并确保代码的效率和稳定性。这可能涉及到多线程、内存管理以及优化技术。同时，为了验证结果...
双目立体视觉三维重建是计算机视觉领域中的一个重要研究方向，它通过分析两个或多个不同视角的图像来恢复场景的三维几何信息。在这个基于C++的项目中，我们将深入探讨这一技术的设计与实现。 首先，我们要理解双目...
【基于八叉树分解的三维重建】是一种在计算机图形学领域广泛应用的技术，它主要用于构建和表示复杂的三维模型。这项技术的核心在于将三维空间利用八叉树（Octree）的数据结构进行分割和组织，以实现高效的数据存储、...
结构光cuda多线程程序开发可用于基于相位的单目或者双目结构光三维重建系统 0.5s500w像素三维重建。
在计算机视觉领域，三维重建是一项关键技术，它涉及从多个二维图像中恢复出场景的三维几何信息。本主题将深入探讨“基于窗口的密集点匹配及三维重建”这一概念，以及如何利用OpenCV库来实现这一过程。 首先，我们来...
总之，JavaScript实现的高效三维重建与生成，结合大高斯重建模型，是计算机视觉和Web开发领域的交叉点，它结合了数学、图形学和编程技术，为用户提供了一种在浏览器中探索和呈现三维世界的创新方式。通过深入学习和...
"一种改进ORB特征匹配的半稠密三维重建ORB-SLAM算法" 本文主要介绍了一种改进的ORB特征匹配的半稠密三维重建ORB-SLAM算法，该算法可以实时建立稠密的三维地图，解决了传统ORB-SLAM算法只能建立稀疏点云图的问题。 ...
锥束计算机断层扫描（CT）是一种广泛应用于医学成像的技术，它能够提供组织和器官的三维图像。这种技术在诊断和治疗计划方面尤其重要，能够帮助医生准确识别出病灶。由于医学成像对于时间要求较高，快速重建图像对于...
关键词“捆绑调整”、“计算机集群”、“图形处理器”和“运动相机重建三维结构”揭示了文章的主要研究对象和应用背景。该文献的发表不仅对学术界产生了积极的影响，同时也为实际的三维重建项目提供了技术支持，尤其...
泊松重建是一种在3D计算机视觉领域广泛应用的技术，主要用于从二维图像序列或散乱的三维点云数据中恢复出连续、光滑的三维表面。这项技术是基于泊松方程的数值解法，能够生成高质量的三维几何模型。下面将详细阐述...
FDK锥束CT重建算法是计算机断层扫描（CT）成像领域中常用的一种迭代重建方法。它由Feldkamp、Davis和Kress三位科学家提出，主要用于解决锥形X射线束数据下的三维图像重建问题。该算法的基本思想是将三维重建问题转化...
ORBSLAM3是一种基于视觉SLAM（Visual SLAM）算法，主要用于实时三维重建和定位。下面是对ORBSLAM3线程分解的知识点整理： 1. 初始化 在ORBSLAM3中，初始化过程是通过MonocularInertialization（）函数实现的，该...
CT图像重建是医学成像领域中的一个重要技术，它利用计算机断层扫描（Computed Tomography, CT）设备收集到的原始投影数据，通过特定的算法重建出人体内部的二维或三维图像。这个过程涉及到数学、物理以及计算机科学...
6. 片面扩散：一种基于片面的特征提取方法，用于三维重建。 7. 多影像处理：对多个图像进行处理，用于三维重建。 8. 高性能服务器：使用高性能服务器来进行计算，提高计算效率。 9. 并行计算平台：使用并行计算平台...
可以利用STL（Standard Template Library）容器存储和操作图像数据，通过多线程技术提升计算效率，同时，VTK库的C++接口使开发者能便捷地调用相关功能，如读取DICOM格式的CT图像，进行滤波反投影等图像重建操作。...