程序博客网 > 中国海军实力 知乎

java多线程总结（十分详细）

来源：互联网 发布：中国海军实力 知乎 编辑：程序博客网 时间：2024/05/17 23:32

java中的多线程

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

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

1
2
3
4
5
6
7
8
9
10
11
12
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
28
/**
 * @author Rollen-Holt 继承Thread类,直接调用run方法
 * */
class hello extends Thread {
 
    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();
    }
 
    private String name;
}

【运行结果】：

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();
    }

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

A运行     0

B运行     0

B运行     1

B运行     2

B运行     3

B运行     4

A运行     1

A运行     2

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
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
12
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
30
/**
 * @author Rollen-Holt 实现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方法，这种操作模式其实就是代理模式。关于代理模式，我曾经写过一个小例子呵呵，大家有兴趣的话可以看一下：http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144847.html

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
23
/**
 * @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 Rollen-Holt
 * 取得线程的名称
 * */
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 Rollen-Holt 判断线程是否启动
 * */
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 Rollen-Holt 线程的强制执行
     * */
    class helloimplements 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

．．．

 

线程的休眠：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * @author Rollen-Holt 线程的休眠
 * */
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

 

线程的中断：

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
/**
 * @author Rollen-Holt 线程的中断
 * */
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 Rollen-Holt 后台线程
 * */
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
23
/**
 * @author Rollen-Holt 线程的优先级
 * */
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（）方法，将一个线程的操作暂时交给其他线程执行。

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 线程的优先级
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+"运行"+i);
            if(i==3){
                System.out.println("线程的礼让");
                Thread.currentThread().yield();
            }
        }
    }
 
    public static void main(String[] args) {
        Thread h1=new Thread(new hello(),"A");
        Thread h2=new Thread(new hello(),"B");
        h1.start();
        h2.start();
         
    }
}

A运行0

A运行1

A运行2

A运行3

线程的礼让

A运行4

B运行0

B运行1

B运行2

B运行3

线程的礼让

B运行4

 

 

同步和死锁：

【问题引出】:比如说对于买票系统，有下面的代码：

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
/**
 * @author Rollen-Holt
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<10;++i){
            if(count>0){
                try{
                    Thread.sleep(1000);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(count--);
            }
        }
    }
 
    public static void main(String[] args) {
        hello he=new hello();
        Thread h1=new Thread(he);
        Thread h2=new Thread(he);
        Thread h3=new Thread(he);
        h1.start();
        h2.start();
        h3.start();
    }
    private int count=5;
}

【运行结果】：

5

4

3

2

1

0

-1

这里出现了-1，显然这个是错的。，应该票数不能为负值。

如果想解决这种问题，就需要使用同步。所谓同步就是在统一时间段中只有有一个线程运行，

其他的线程必须等到这个线程结束之后才能继续执行。

【使用线程同步解决问题】

采用同步的话，可以使用同步代码块和同步方法两种来完成。

 

【同步代码块】：

语法格式：

synchronized（同步对象）{

 //需要同步的代码

}

但是一般都把当前对象this作为同步对象。

比如对于上面的买票的问题，如下：

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
30
/**
 * @author Rollen-Holt
 * */
class hello implements Runnable {
    public void run() {
        for(int i=0;i<10;++i){
            synchronized (this) {
                if(count>0){
                    try{
                        Thread.sleep(1000);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(count--);
                }
            }
        }
    }
 
    public static void main(String[] args) {
        hello he=new hello();
        Thread h1=new Thread(he);
        Thread h2=new Thread(he);
        Thread h3=new Thread(he);
        h1.start();
        h2.start();
        h3.start();
    }
    private int count=5;
}

【运行结果】：（每一秒输出一个结果）

5

4

3

2

1

【同步方法】

也可以采用同步方法。

语法格式为synchronized 方法返回类型方法名（参数列表）{

    // 其他代码

}

现在，我们采用同步方法解决上面的问题。

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
30
31
32
33
/**
 * @author Rollen-Holt
 * */
class hello implements Runnable {
    public void run() {
        for (int i =0; i <10; ++i) {
            sale();
        }
    }
 
    public synchronized void sale() {
        if (count >0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(count--);
        }
    }
 
    public static void main(String[] args) {
        hello he = new hello();
        Thread h1 = new Thread(he);
        Thread h2 = new Thread(he);
        Thread h3 = new Thread(he);
        h1.start();
        h2.start();
        h3.start();
    }
 
    private int count =5;
}

【运行结果】（每秒输出一个）

5

4

3

2

1

提醒一下，当多个线程共享一个资源的时候需要进行同步，但是过多的同步可能导致死锁。

此处列举经典的生产者和消费者问题。

【生产者和消费者问题】

先看一段有问题的代码。

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
class Info {
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    private String name ="Rollen";
    private int age =20;
}
 
/**
 * 生产者
 * */
class Producer implements Runnable{
    private Info info=null;
    Producer(Info info){
        this.info=info;
    }
     
    public void run(){
        boolean flag=false;
        for(int i=0;i<25;++i){
            if(flag){
                this.info.setName("Rollen");
                try{
                    Thread.sleep(100);
                }catch (Exception e) {
                    e.printStackTrace();
                }
                this.info.setAge(20);
                flag=false;
            }else{
                this.info.setName("chunGe");
                try{
                    Thread.sleep(100);
                }catch (Exception e) {
                    e.printStackTrace();
                }
                this.info.setAge(100);
                flag=true;
            }
        }
    }
}
/**
 * 消费者类
 * */
class Consumer implements Runnable{
    private Info info=null;
    public Consumer(Info info){
        this.info=info;
    }
     
    public void run(){
        for(int i=0;i<25;++i){
            try{
                Thread.sleep(100);
            }catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(this.info.getName()+"<---->"+this.info.getAge());
        }
    }
}
 
/**
 * 测试类
 * */
class hello{
    public static void main(String[] args) {
        Info info=new Info();
        Producer pro=new Producer(info);
        Consumer con=new Consumer(info);
        new Thread(pro).start();
        new Thread(con).start();
    }
}

【运行结果】：

Rollen<---->100

chunGe<---->20

chunGe<---->100

Rollen<---->100

chunGe<---->20

Rollen<---->100

Rollen<---->100

Rollen<---->100

chunGe<---->20

chunGe<---->20

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

Rollen<---->100

chunGe<---->20

大家可以从结果中看到，名字和年龄并没有对于。

 

那么如何解决呢？

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
class Info {
     
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public synchronized void set(String name,int age){
        this.name=name;
        try{
            Thread.sleep(100);
        }catch (Exception e) {
            e.printStackTrace();
        }
        this.age=age;
    }
     
    public synchronized void get(){
        try{
            Thread.sleep(100);
        }catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(this.getName()+"<===>"+this.getAge());
    }
    private String name ="Rollen";
    private int age =20;
}
 
/**
 * 生产者
 * */
class Producer implements Runnable {
    private Info info =null;
 
    Producer(Info info) {
        this.info = info;
    }
 
    public void run() {
        boolean flag =false;
        for (int i =0; i <25; ++i) {
            if (flag) {
                 
                this.info.set("Rollen",20);
                flag = false;
            } else {
                this.info.set("ChunGe",100);
                flag = true;
            }
        }
    }
}
 
/**
 * 消费者类
 * */
class Consumer implements Runnable {
    private Info info =null;
 
    public Consumer(Info info) {
        this.info = info;
    }
 
    public void run() {
        for (int i =0; i <25; ++i) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
            this.info.get();
        }
    }
}
 
/**
 * 测试类
 * */
class hello {
    public static void main(String[] args) {
        Info info = new Info();
        Producer pro = new Producer(info);
        Consumer con = new Consumer(info);
        new Thread(pro).start();
        new Thread(con).start();
    }
}

【运行结果】：

Rollen<===>20

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

Rollen<===>20

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

ChunGe<===>100

从运行结果来看，错乱的问题解决了，现在是Rollen 对应20，ChunGe对于100

，但是还是出现了重复读取的问题，也肯定有重复覆盖的问题。如果想解决这个问题，就需要使用Object类帮忙了、

，我们可以使用其中的等待和唤醒操作。

要完成上面的功能，我们只需要修改Info类饥渴，在其中加上标志位，并且通过判断标志位完成等待和唤醒的操作，代码如下：

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
class Info {
     
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public synchronized void set(String name,int age){
        if(!flag){
            try{
                super.wait();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
        this.name=name;
        try{
            Thread.sleep(100);
        }catch (Exception e) {
            e.printStackTrace();
        }
        this.age=age;
        flag=false;
        super.notify();
    }
     
    public synchronized void get(){
        if(flag){
            try{
                super.wait();
            }catch (Exception e) {
                e.printStackTrace();
            }
        }
         
        try{
            Thread.sleep(100);
        }catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(this.getName()+"<===>"+this.getAge());
        flag=true;
        super.notify();
    }
    private String name ="Rollen";
    private int age =20;
    private boolean flag=false;
}
 
/**
 * 生产者
 * */
class Producer implements Runnable {
    private Info info =null;
 
    Producer(Info info) {
        this.info = info;
    }
 
    public void run() {
        boolean flag =false;
        for (int i =0; i <25; ++i) {
            if (flag) {
                 
                this.info.set("Rollen",20);
                flag = false;
            } else {
                this.info.set("ChunGe",100);
                flag = true;
            }
        }
    }
}
 
/**
 * 消费者类
 * */
class Consumer implements Runnable {
    private Info info =null;
 
    public Consumer(Info info) {
        this.info = info;
    }
 
    public void run() {
        for (int i =0; i <25; ++i) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
            this.info.get();
        }
    }
}
 
/**
 * 测试类
 * */
class hello {
    public static void main(String[] args) {
        Info info = new Info();
        Producer pro = new Producer(info);
        Consumer con = new Consumer(info);
        new Thread(pro).start();
        new Thread(con).start();
    }
}
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
【程序运行结果】：
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
ChunGe<===>100
Rollen<===>20
先在看结果就可以知道，之前的问题完全解决。

《完》

PS（写在后面）：

本人深知学的太差，所以希望大家能多多指点。另外，关于多线程其实有很多的知识，由于目前我也就知道的不太多，写了一些常用的。虽然在操作系统这门课上学了很多的线程和进程，比如银行家算法等等的，以后有时间在补充，大家有什么好资料可以留个言，大家一起分享一下，谢谢了。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


============================================================================== 
我喜欢程序员，他们单纯、固执、容易体会到成就感；面对压力，能够挑灯夜战不眠不休；面对困难，能够迎难而上挑战自我。他
们也会感到困惑与傍徨，但每个程序员的心中都有一个比尔盖茨或是乔布斯的梦想“用智慧开创属于自己的事业”。我想说的是，其
实我是一个程序员
==============================================================================
绿色通道： 好文要顶 关注我 收藏该文与我联系 
Rollen Holt
关注 - 39
粉丝 - 1352
+加关注
66
0
(请您对文章做出评价)
« 上一篇：棋盘覆盖--递归分治java实现
» 下一篇：java中类的生命周期
  • 分类: Java
< Prev12
ADD YOUR COMMENT
  1. #51楼 白开水加糖  2013-09-28 21:25
    @yyg1982
    会不会是单核CPU执行的时候不行？ 我觉得楼主写的么错啊
    支持(0)反对(0)
  2. #52楼 shuyy_com  2013-10-28 13:26
    写得很好，谢谢，辛苦了
    支持(1)反对(0)
  3. #53楼 沙漠中的大奔  2013-11-02 22:07
    楼主 为什么不学java了呢？
    支持(0)反对(0)
  4. #54楼[楼主] Rollen Holt  2013-11-04 10:26
    @沙漠中的大奔
    工作的关系，哈哈
    支持(0)反对(0)
  5. #55楼 你的名字我的姓氏  2013-11-28 16:21
    不错，讲的很细
    支持(0)反对(0)
  6. #56楼 道上的追逐  2013-12-26 09:36
    不错很详细，适合我们这些新手
    支持(0)反对(0)
  7. #57楼 会呼吸的鱼  2013-12-27 11:40
    很好，lz辛苦了
    支持(0)反对(0)
  8. #58楼 fkblog.org  2014-01-13 09:50
    不错，我也推荐个Java多线程入门讲解：http://www.w3cschool.cc/java/ava-multithreading.html
    支持(2)反对(0)
  9. #59楼 reiben  2014-01-28 16:41
    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();
        }
    }

    这个分配了3个线程对象，但运行的都是同一个线程MyThread，内存中就一份COUNT=5.

    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;
    }

    这个新建了3个线程,内存中有三份COUNT=5.

    跑出来的结果自然不一样了。是可以共享的。
    支持(2)反对(0)
  10. #60楼 reiben  2014-01-28 16:43
    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;
    }

    把
    private int count = 5;
    改成
    private static int count = 5;试试
    支持(1)反对(0)
  11. #61楼 Vitt不再孤单  2014-01-30 00:14
    每次看到你们这样的笔记就会想，当初自己不学测控多好····妈蛋····
    支持(0)反对(0)
  12. #62楼 BIGBIRD大鸟  2014-02-10 22:41
    写的真好！ 很详细了！
    支持(0)反对(0)
  13. #63楼 无翼神  2014-02-13 20:03
    写的不错，例子也不错
    支持(0)反对(0)
  14. #64楼 simpman  2014-02-27 15:48
    大家可以想象，如果这个是一个买票系统的话，如果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();
    }
    }

    这个也会出现两个窗口卖同一张票的情况。应该用synchronized给代码加锁吧。
    支持(1)反对(0)
  15. #65楼 Bactryki  2014-04-18 11:29
    真棒！
    支持(0)反对(0)
  16. #66楼 beyondchina  2014-04-21 13:46
    mark. 写得很不错哦。
    支持(0)反对(0)
  17. #67楼 小咚  2014-04-22 17:24
    public synchronized void set(String name, int age){
    if(!flag){
    try{
    super.wait();
    }catch (Exception e) {
    e.printStackTrace();
    }
    }
    this.name=name;
    try{
    Thread.sleep(100);
    }catch (Exception e) {
    e.printStackTrace();
    }
    this.age=age;
    flag=false;
    super.notify();
    }

    public synchronized void get(){
    if(flag){
    try{
    super.wait();
    }catch (Exception e) {
    e.printStackTrace();
    }
    }

    try{
    Thread.sleep(100);
    }catch (Exception e) {
    e.printStackTrace();
    }
    System.out.println(this.getName()+"<===>"+this.getAge());
    flag=true;
    super.notify();
    }
    private String name = "Rollen";
    private int age = 20;
    private boolean flag=false;
    }

    这个生产者和消费者的判断应该反了把
    生产应该是set 应该是!flag 没有就创建 然后激活get 有就等待消费
    消费应该是get 应该是flag 有就消费 然后激活set 没有就等待生产
    支持(1)反对(0)
  18. #68楼 拉姆塞  2014-04-23 09:14
    学习了，谢谢
    支持(0)反对(0)
  19. #69楼 youngjoy  2014-05-17 00:15
    写的太好。学习。膜拜。
    支持(0)反对(0)
  20. #70楼 水澜。影雪  2014-05-19 10:30
    很好，非常适合我们新手~
    支持(0)反对(0)
  21. #71楼 xmu_lomo  2014-05-21 08:44
    楼主在线程的强制执行那段是怎么样得到那样的结果的...我的至少得在run中执行5次及5次以上才可能在main线程10以后join， 0-0楼主的输出结果概率略小呀，...
    支持(0)反对(0)
  22. #72楼 Me.thinking  2014-05-21 16:12
    good
    支持(0)反对(0)
  23. #73楼 秦寅  2014-05-29 17:39
    楼主在说明多线程两种实现方式资源共享的时候，demo卖票是错误的。
    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;
    }
    这个继承Thread实现的方法，在main方法中其实是创建了是三个线程，所以运行的时候输出的是15条记录。但是如下实例：

    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();
    }
    }
    这个是通过实现Runnable接口实现资源共享中，只是创建了一个线程。在如下是我自己写的实例，同样可以实现资源共享的目的：
    public class Hello extends Thread{

    public Hello() {

    }

    public Hello(String name) {
    this.name = name;
    }

    private int ticket=10;
    public void run() {
    for (int i = 0; i < 5; i++) {
    if(ticket>0){
    System.out.println(Thread.currentThread().getName()+ "--" +this.ticket--);
    }
    }
    }

    public static void main(String[] args) {
    Hello h3 = new Hello();
    new Thread(h3, "窗口1").start();
    new Thread(h3, "窗口2").start();
    new Thread(h3, "窗口3").start();
    }

    private String name;

    }
0 0
中国海军实力 知乎 中国海军实力 知乎
原创粉丝点击
热门IT博客
java bio全称java bio全称
即时通讯app源码即时通讯app源码
海康显示无网络视频
腾讯视频 mac 10.9.5
u盘在mac上只读
玩具行业前景 知乎
nginx 别名 404
mac osx 10.12 下载
广州思纬网络
今天淘宝登录不上去
程序员老黄历
手机系统数据恢复
阿里云幕布 收费
淘宝包装类目店铺风格
阿里小号登录用淘宝
c语言入门教程电子书
three.js 室内全景图
福建江夏学院教务网络
淘宝直通车优化技巧
医药软件排行
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 陶制烧水壶 天道制霸计划 向往开始制霸娱乐 从向往开始制霸娱乐 制霸好莱坞 校草制霸录 制霸全球 从相声制霸娱乐圈 西游制霸洪荒 西游之制霸洪荒 制霸编剧界 制霸娱乐圈 从封神开始制霸洪荒 科技制霸 制霸第三帝国 制霸 穿成霸总后我制霸娱乐圈 穿成霸总后制霸娱乐圈 高校制霸max 都市强化系统全领域制霸 中国刷脸支付达亿人 刷墙面漆多久可以住人 qq群免费刷1000人进群 乘车码可以刷几个人 五人小队怎么刷完美厄运 暗黑3猎魔人单刷流派 探探一直刷没人配对 烛龙殿25人单刷顺序 多人组队刷副本手游 牧原试用期刷人的比例 华科复试刷人厉害吗 银行体检会刷掉哪些人 刷脸支付合伙人 无人深空纳米星团怎么刷 给主播刷礼物的都是什么人 东南大学复试刷人多不 大兴机场外国人怎么刷脸 我有一座诸天刷人城 支付宝乘车码可以刷几个人 重庆师范大学复试刷人 东华大学考研复试刷人

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里