在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. 用php连接数据库，并执行数据库操作

    1,建立与数据库之间的连接 (能通过php代码执行一个SQL语句得到查询的结果) <?php mysqli_connect(' , 'demo01'); 这里要注意两个问题: ①mysqli 是 ...

  2. https和http的post发送总结

    本文为转贴内容,感谢作者阿进! 需要转发数据到客户的https的服务器上出现一系列问题总结如下: 1.因为是https首先考虑到用最新的控件NetHTTPClient(只有在XE8以上才有). 2.客 ...

  3. ansible 配置文件设置

    目录 ansible 配置文件设置 一.ansible configuration settings 二.ansible 配置文件查找顺序(从上到下,依次查找) 三.附录ansible配置参数 ans ...

  4. fastadmin中上传配置

    配置文件位于下图,默认代码如下 <?php //上传配置 return [ /** * 上传地址,默认是本地上传 */ 'rootpath' => '/uploads/', 'upload ...

  5. casperjs 源码

    1.首当其冲github 地址: https://github.com/casperjs

  6. YII2组件之GridView

    采用的是yii2.0.14版本,为了学习方便,以问答式书写. 开始GridView GridView主要是为了实现表格复用,尤其我们做后台的时候,你发现表单和表格占据了大部分页面,而表格的样式又是高度 ...

  7. shell脚本基础和grep文本处理工具企业应用3

    文本处理工具:    linux上文本处理三剑客        grep,egrep,fgrep:文本过滤工具(模式:pattern)工具            grep:默认支持的是基本正则表达式: ...

  8. D - Nested Segments CodeForces - 652D (离散化+树桩数组)

    D - Nested Segments CodeForces - 652D You are given n segments on a line. There are no ends of some ...

  9. HH的项链 HYSBZ - 1878 （莫队/ 树状数组）

    HH有一串由各种漂亮的贝壳组成的项链.HH相信不同的贝壳会带来好运,所以每次散步 完后,他都会随意取出一 段贝壳,思考它们所表达的含义.HH不断地收集新的贝壳,因此他的项链变得越来越长.有一天,他突然 ...

  10. libusb_bulk_transfer返回值不是0

    libusb_bulk_transfer返回值不是0 libusb_bulk_transfer返回值不是0libusb_bulk_transfer返回值不是0 ?????