在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. extjs 表格为可编辑，保存后为不可编辑状态

    画出表格 编辑后 思路:在初始时设置一个状态,panduan='0',此时,就是一个不可编辑的input,当点击编辑时,改变panduan = '1',即可编辑.保存是加入正则表达式的判断,在将pan ...

  2. SQL 多表查询展示

    ########################多表########################SELECT COUNT(*) FROM MEMBER1 A; 查询出来的结果为43行数据: SEL ...

  3. Action向视图传值的6种方式（转）

    在使用ASP.NET MVC进行项目开发时,经常会碰到从Action向视图传值的问题,今天我就把我所知道的方式总结了一下,分成了以下六种: 1.使用ViewData进行传值 在Action中,有如下代 ...

  4. Windows 7上QTP11破解及java等插件破解方法

    QTP11破解方法: 1.准备文件 注册机mgn-mqt82.exe 2.安装QTP11 3.运行注册机mgn-mqt82.exe 如果运行mgn-mqt82.exe 没有反应-,请注意关掉暂时关掉杀 ...

  5. Oracle笔记（三） Scott用户的表结构

    在Oracle的学习之中,重点使用的是SQL语句,而所有的SQL语句都要在scott用户下完成,这个用户下一共有四张表,可以使用: SELECT * FROM tab; 查看所有的数据表的名称,如果现 ...

  6. centos 7 安装 Git-2.23.0

    Git是一个免费的开源 分布式版本控制系统,旨在快速高效地处理从小型到大型项目的所有内容. Git 易于学习,占地面积小,具有闪电般的快速性能. 它具有诸如Subversion,CVS,Perforc ...

  7. Nginx的入门

    Nginx 入门 一.正向代理和反向代理 1.正向代理 正向代理(forward proxy) ,一个位于客户端和原始服务器之间的服务器,为了从原始服务器取得内容,客户端向代理发送一个请求并制定目标( ...

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

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

  9. 【杭电多校第七场】A + B = C

    原题: Given a,b,c, find an arbitrary set of x,y,z such that a*10^x+b*10^y=c*10^z and 0≤x,y,z≤10^6. 给你三 ...

  10. Springboot整合Ehcache 解决Mybatis二级缓存数据脏读 -详细

    前面有写了一篇关于这个,但是这几天又改进了一点,就单独一篇在详细说明一下 配置 application.properties ,启用Ehcache # Ehcache缓存 spring.cache.t ...