在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。

对于直接继承Thread的类来说，代码大致框架是：

1
2
3
4
5
6
7
8
9
10
11
class 类名 extends Thread{ 
方法1; 
方法2； 
… 
public void run(){ 
// other code… 
} 
属性1； 
属性2； 
… 
} 

先看一个简单的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/**
 * @author Hashsound 继承Thread类,直接调用run方法
 * */ 
class hello extends Thread { 
   
    private String name; 
   
    public hello() { 
    } 
   
    public hello(String name) { 
        this.name = name; 
    } 
   
    public void run() { 
        for (int i = 0; i < 5; i++) { 
            System.out.println(name + "运行 " + i); 
        } 
    } 
   
    public static void main(String[] args) { 
        hello h1 = new hello("A"); 
        hello h2 = new hello("B"); 
        h1.run(); 
        h2.run(); 
    } 
} 

【运行结果】：

A运行     0
A运行     1
A运行     2
A运行     3
A运行     4
B运行     0
B运行     1
B运行     2
B运行     3
B运行     4

我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start()方法。
当我们把上面的主函数修改为如下所示的时候：

1
2
3
4
5
6
public static void main(String[] args) { 
        hello h1=new hello("A"); 
        hello h2=new hello("B"); 
        h1.start(); 
        h2.start(); 
} 

然后运行程序，输出的可能的结果如下：

B运行 0
B运行 1
B运行 2
A运行 0
A运行 1
A运行 2
B运行 3
B运行 4
A运行 3
A运行 4

因为需要用到CPU的资源，所以每次的运行结果基本是都不一样的，呵呵。
注意：虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。
那么：为什么我们不能直接调用run（）方法呢？
我的理解是：线程的运行需要本地操作系统的支持。
如果你查看start的源代码的时候，会发现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 || this != me) 
            throw new IllegalThreadStateException(); 
        group.add(this); 
        start0(); 
        if (stopBeforeStart) { 
        stop0(throwableFromStop); 
    } 
} 
private native void start0(); 

注意我用红色加粗的那一条语句，说明此处调用的是start0（）。并且这个这个方法用了native关键字，次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。
但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。
通过实现Runnable接口：
大致框架是：

来先看一个小例子吧：

1
2
3
4
5
6
7
8
9
10
11
class 类名 implements Runnable{ 
方法1; 
方法2； 
… 
public void run(){ 
// other code… 
} 
属性1； 
属性2； 
… 
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
 * @author Hashsound 实现Runnable接口
 * */ 
class hello implements Runnable { 
    
    public hello() { 
    
    } 
    
    public hello(String name) { 
        this.name = name; 
    } 
    
    public void run() { 
        for (int i = 0; i < 5; i++) { 
            System.out.println(name + "运行     " + i); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello h1=new hello("线程A"); 
        Thread demo= new Thread(h1); 
        hello h2=new hello("线程Ｂ"); 
        Thread demo1=new Thread(h2); 
        demo.start(); 
        demo1.start(); 
    } 
    private String name; 
}

【可能的运行结果】：

线程A运行     0
线程Ｂ运行    0
线程Ｂ运行    1
线程Ｂ运行    2
线程Ｂ运行    3
线程Ｂ运行    4
线程A运行     1
线程A运行     2
线程A运行     3
线程A运行     4

关于选择继承Thread还是实现Runnable接口？
其实Thread也是实现Runnable接口的：

1
2
3
4
5
6
7
8
class Thread implements Runnable { 
    //… 
public void run() { 
        if (target != null) { 
             target.run(); 
        } 
     } 
} 

其实Thread中的run方法调用的是Runnable接口的run方法。不知道大家发现没有，Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式。

Thread和Runnable的区别：

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * @author Rollen-Holt 继承Thread类，不能资源共享
 * */ 
class hello extends Thread { 
    public void run() { 
        for (int i = 0; i < 7; i++) { 
            if (count > 0) { 
                System.out.println("count= " + count--); 
            } 
        } 
    } 
    
    public static void main(String[] args) { 
        hello h1 = new hello(); 
        hello h2 = new hello(); 
        hello h3 = new hello(); 
        h1.start(); 
        h2.start(); 
        h3.start(); 
    } 
    private int count = 5; 
} 

【运行结果】：

count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1
count= 5
count= 4
count= 3
count= 2
count= 1

大家可以想象，如果这个是一个买票系统的话，如果count表示的是车票的数量的话，说明并没有实现资源的共享。

我们换为Runnable接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class MyThread implements Runnable{ 
    
    private int ticket = 5;  //5张票 
    
    public void run() { 
        for (int i=0; i<=20; i++) { 
            if (this.ticket > 0) { 
                System.out.println(Thread.currentThread().getName()+ "正在卖票"+this.ticket--); 
            } 
        } 
    } 
} 
public class lzwCode { 
        
    public static void main(String [] args) { 
        MyThread my = new MyThread(); 
        new Thread(my, "1号窗口").start(); 
        new Thread(my, "2号窗口").start(); 
        new Thread(my, "3号窗口").start(); 
    } 
} 

【运行结果】：

count= 5
count= 4
count= 3
count= 2
count= 1

总结一下吧：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
所以，本人建议大家尽量实现接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * @author Hashsound
 * 取得线程的名称
 * */ 
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName()); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello he = new hello(); 
        new Thread(he,"A").start(); 
        new Thread(he,"B").start(); 
        new Thread(he).start(); 
    } 
} 

【运行结果】：

A
A
A
B
B
B
Thread-0
Thread-0
Thread-0

说明如果我们没有指定名字的话，系统自动提供名字。
提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。
在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。

判断线程是否启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * @author Hashsound 判断线程是否启动
 * */ 
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName()); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello he = new hello(); 
        Thread demo = new Thread(he); 
        System.out.println("线程启动之前---》" + demo.isAlive()); 
        demo.start(); 
        System.out.println("线程启动之后---》" + demo.isAlive()); 
    } 
} 

【运行结果】

线程启动之前---》false
线程启动之后---》true
Thread-0
Thread-0
Thread-0

主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。

线程的强制执行：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
 * @author Hashsound 线程的强制执行
 * */ 
class hello implements Runnable { 
    public void run() { 
        for (int i = 0; i < 3; i++) { 
            System.out.println(Thread.currentThread().getName()); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello he = new hello(); 
        Thread demo = new Thread(he,"线程"); 
        demo.start(); 
        for(int i=0;i<50;++i){ 
            if(i>10){ 
                try{ 
                    demo.join();  //强制执行demo 
                }catch (Exception e) { 
                    e.printStackTrace(); 
                } 
            } 
            System.out.println("main 线程执行-->"+i); 
        } 
    } 
} 

【运行的结果】：

main 线程执行-->0
main 线程执行-->1
main 线程执行-->2
main 线程执行-->3
main 线程执行-->4
main 线程执行-->5
main 线程执行-->6
main 线程执行-->7
main 线程执行-->8
main 线程执行-->9
main 线程执行-->10
线程
线程
线程
main 线程执行-->11
main 线程执行-->12
main 线程执行-->13
．．．

线程的休眠：

/**
 * @author Hashsound 线程的休眠
 * */
class hello implements Runnable {
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + i);
        }
    }  

    public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he, "线程");
        demo.start();
    }
}

【运行结果】：（结果每隔2s输出一个）

线程0
线程1
线程2

线程的中断：

/**
 * @author Hashsound 线程的中断
 * */
class hello implements Runnable {
    public void run() {
        System.out.println("执行run方法");
        try {
            Thread.sleep(10000);
            System.out.println("线程完成休眠");
        } catch (Exception e) {
            System.out.println("休眠被打断");
            return;  //返回到程序的调用处
        }
        System.out.println("线程正常终止");
    }  

    public static void main(String[] args) {
        hello he = new hello();
        Thread demo = new Thread(he, "线程");
        demo.start();
        try{
            Thread.sleep(2000);
        }catch (Exception e) {
            e.printStackTrace();
        }
        demo.interrupt(); //2s后中断线程
    }
}

【运行结果】：

执行run方法
休眠被打断

在java程序中，只要前台有一个线程在运行，整个java程序进程不会小时，所以此时可以设置一个后台线程，这样即使java进程小时了，此后台线程依然能够继续运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * @author Hashsound 后台线程
 * */ 
class hello implements Runnable { 
    public void run() { 
        while (true) { 
            System.out.println(Thread.currentThread().getName() + "在运行"); 
        } 
    } 
    
    public static void main(String[] args) { 
        hello he = new hello(); 
        Thread demo = new Thread(he, "线程"); 
        demo.setDaemon(true); 
        demo.start(); 
    } 
} 

虽然有一个死循环，但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。

线程的优先级：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * @author Hashsound 线程的优先级
 * */ 
class hello implements Runnable { 
    public void run() { 
        for(int i=0;i<5;++i){ 
            System.out.println(Thread.currentThread().getName()+"运行"+i); 
        } 
    } 
    
    public static void main(String[] args) { 
        Thread h1=new Thread(new hello(),"A"); 
        Thread h2=new Thread(new hello(),"B"); 
        Thread h3=new Thread(new hello(),"C"); 
        h1.setPriority(8); 
        h2.setPriority(2); 
        h3.setPriority(6); 
        h1.start(); 
        h2.start(); 
        h3.start(); 
    } 
} 

【运行结果】：

A运行0
A运行1
A运行2
A运行3
A运行4
B运行0
C运行0
C运行1
C运行2
C运行3
C运行4
B运行1
B运行2
B运行3
B运行4

但是请读者不要误以为优先级越高就先执行。谁先执行还是取决于谁先去的CPU的资源、

另外，主线程的优先级是5.

线程的礼让。

在线程操作中，也可以使用yield（）方法，将一个线程的操作暂时交给其他线程执行。

Java多线程深入理解的更多相关文章

  1. java多线程的理解

    java多线程的理解   线程的5种状态:新建,就绪,运行,阻塞,死亡. Thread.sleep:线程  运行状态 转为  阻塞状态,(其它线程启动运行) Thread.yield:   线程 运行 ...

  2. （转载）Java多线程入门理解

    转载出处http://blog.csdn.net/evankaka 写在前面的话:此文只能说是java多线程的一个入门,其实Java里头线程完全可以写一本书了,但是如果最基本的你都学掌握好,又怎么能更 ...

  3. synchronized与static synchronized 的差别、synchronized在JVM底层的实现原理及Java多线程锁理解

    本Blog分为例如以下部分: 第一部分:synchronized与static synchronized 的差别 第二部分:JVM底层又是怎样实现synchronized的 第三部分:Java多线程锁 ...

  4. 温故知新-java多线程&深入理解线程池

    文章目录 摘要 java中的线程 java中的线程池 线程池技术 线程池的实现原理 简述 ThreadPoolExecutor是如何运行的? 线程池运行的状态和线程数量 任务执行机制 队列缓存 Wor ...

  5. 谈谈你对Java多线程的理解以及多线程的实现方式

    说线程之前先说进程,何为进程?进程就是正在进行中的程序.比如电脑同时在运行QQ进程.cmd进程.wps进程.飞秋进程等.在某一时刻,CPU只能执行一个程序,只是在做快速切换,我们肉眼看不出来. 比如: ...

  6. Java多线程的理解和实例

    编写具有多线程程序经常会用到的方法:run(), start(), wait(), notify(), notifyAll(), sleep(), yield(), join() 还有一个关键字:sy ...

  7. Java多线程 -- 深入理解JMM（Java内存模型） --（五）锁

    锁的释放-获取建立的happens before 关系 锁是Java并发编程中最重要的同步机制.锁除了让临界区互斥执行外,还可以让释放锁的线程向获取同一个锁的线程发送消息. 下面是锁释放-获取的示例代 ...

  8. 从JAVA多线程理解到集群分布式和网络设计的浅析

    对于JAVA多线程的应用非常广泛,现在的系统没有多线程几乎什么也做不了,很多时候我们在何种场合如何应用多线程成为一种首先需要选择的问题,另外关于java多线程的知识也是非常的多,本文中先介绍和说明一些 ...

  9. 关于java多线程中异常捕获的理解

    在java多线程程序中,所有线程都不允许抛出未捕获的checked exception(比如sleep时的InterruptedException),也就是说各个线程需要自己把自己的checked e ...

随机推荐

  1. 基于SQL Server日志链查看数据库insert/update/delete操作（一）

    在MSSQLServer2008下的语句 不同版本可能语句会有微小差别 SELECT [Slot ID], [Transaction ID], Operation, AllocUnitName, [C ...

  2. webpack开启本地服务器与热更新

    第一个webpack本地服务 webpack本地服务相关的一些操作指令与应用 一.第一个webpack本地服务 //工作区间 src//文件夹 index.js//入口文件 index.css//测试 ...

  3. H5移动端弹幕动画实现

    思路 把单个内容编辑好,计算自身宽度,确定初始位置 移动的距离是屏幕宽度 js动态的添加css动画函数,将高度.动画移动时间.动画延迟时间都用随机数控制 代码: html骨架结构 (以三个为例,如果觉 ...

  4. 输入列号得到excel对应的字母列

    zexcel_cell_column 类型是INT4 FUNCTION ZGET_EXCEL_COL. *"----------------------------------------- ...

  5. celery：强大的定时任务模块

    什么是celery 还是一个老生常谈的话题,假设用户注册,首先注册信息入库,然后要调用验证码服务接口,然后根据手机号发送验证码,最后再返回响应给浏览器.但显然调用接口.发送验证码之后成功再给浏览器响应 ...

  6. three.js之创建坐标系网格

    <!DOCTYPE html> <html> <head> <meta charset=utf-8> <title>My first thr ...

  7. pip命令及虚拟环境的建立

    以下命令是pip命令,是帮助我们安装解决python所需要的环境包 列出已经安装的包 pip list 安装要安装的包 pip install 包名 安装特定版本 pip install django ...

  8. 文件浏览：ls&file

    文件浏览主要完成的功能是列出当前目录或指定目录下文件的文件名称以及一些基本的资料. Linux的命令是区分大小写的. 1.  ls:列出当前目录(默认)或指定目录下所有文件,并按字典序排序 语法:ls ...

  9. Django REST Framework(DRF)_第四篇

    DRF分页(总共三种) PageNumberPagination(指定第n页,每页显示n条数据) 说明 既然要用人家的那么我们就先来看下源码,这个分页类源码中举例通过参数指定第几页和每页显示的数据:h ...

  10. 深入理解TransactionTemplate编程式事务

    Spring可以支持编程式事务和声明式事务. Spring提供的最原始的事务管理方式是基于TransactionDefinition.PlatformTransactionManager.Transa ...