java中的多线程

最新推荐文章于 2024-06-19 21:11:55 发布
最新推荐文章于 2024-06-19 21:11:55 发布
阅读量459 收藏
点赞数
文章标签： 多线程 线程

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

．．．

线程的休眠：

?
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

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

那么如何解决呢？

<!--[if !supportLists]-->1）<!--[endif]-->加入同步

<!--[if !supportLists]-->2）<!--[endif]-->加入等待和唤醒

先来看看加入同步会是如何。

?
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（写在后面）：

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


============================================================================== 我喜欢程序员，他们单纯、固执、容易体会到成就感；面对压力，能够挑灯夜战不眠不休；面对困难，能够迎难而上挑战自我。他们也会感到困惑与傍徨，但每个程序员的心中都有一个比尔盖茨或是乔布斯的梦想“用智慧开创属于自己的事业”。我想说的是，其实我是一个程序员。==============================================================================
联系我：

25
0
    (请您对文章做出评价)   
« 上一篇： 棋盘覆盖--递归分治java实现
» 下一篇： java中类的生命周期
posted @ 2011-08-28 20:08 Rollen Holt 阅读(100397) 评论( 36)  编辑 收藏
评论列表
 
#1楼 2011-08-28 20:21 Aulan
不错，顶一下。
 
#2楼 [楼主]  2011-08-28 20:36 Rollen Holt
@Aulan
一起进步
 
#3楼 2011-08-28 22:18 QA龙
支持一下 加油！
 
#4楼 [楼主]  2011-08-28 23:17 Rollen Holt
@QA龙
谢谢，一起加油
 
#5楼 2011-08-29 08:36 张欣男
我看过李兴华的《java开发实战经典》讲述的内容是差不多的，学习了
 
#6楼 [楼主]  2011-08-29 09:16 Rollen Holt
@张欣男
呵呵，有参考。
不错支持一下代码
 
#9楼 2012-02-11 10:53 嗷嗷嗷[未注册用户]
这个应该是有问题的  不是启动一个类就启动一jvm  应该是一个java程序就启动一个jvm实例，一个java进程
 
#10楼 2012-02-13 12:10 哈哈·1[未注册用户]
我也是新手，共同进步啊
 
#11楼 2012-04-05 21:49 第04号
注册了个帐号就是来留言的。很不错的帖子！
 
#12楼 [楼主]  2012-04-06 16:47 Rollen Holt
@第04号
谢谢
 
#13楼 2012-04-26 13:23 Matol Poet
写的很详尽，值得推荐。
 
#14楼 2012-05-07 18:00 铁拐李
引用如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。


错了吧，你看你写的demo，第一个new了3个线程。第二个new了1个线程。你都new 3个线程试试，貌似你的以上结论就不对了
 
#15楼 2012-05-07 18:50 铁拐李
明了了
 
#16楼 2012-05-09 17:03 爱我所艾
理解的不错，但是代码有的地方错了
 
#17楼 2012-07-17 23:40 birdie
还真详细啊。不错。
 
#18楼 2012-08-02 10:43 Front.Tang
不错。
 
#19楼 2012-08-10 12:30 scwsmile
不错哦，赞！～
 
#20楼 2012-08-23 18:24 yyg1982
@铁拐李
经过测试，的确有问题。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class hello implements Runnable {
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 he= new hello();
new Thread(he).start();
<b> new Thread(he).start();
new Thread(he).start();</b>
}
private int count = 5 ;
}


代码按照上面修改后，只所以共享资源没有问题，貌似因为只有一个线程在工作。输入结果：

Thread-1 is running.
count = 5
count = 4
count = 3
count = 2
count = 1
Thread-1 is running.
Thread-1 is running.
 
#21楼 2012-08-23 18:28 yyg1982
@铁拐李
如果创建三个Thread，并且创建独立的Runable的实例作为入参，则结果和Thread没有区别，如下代码：
?
1
2
3
new Thread( new hello()).start();
new Thread( new hello()).start();
new Thread( new hello()).start();


还请楼主解答
 
#22楼 [楼主]  2012-08-23 19:51 Rollen Holt
@yyg1982
首先很感谢你这么认真的看这一篇文章，对于你的回复我其实感到很囧，因为这篇文章是一年前学校看java课程的时候写的笔记，现在一年多了没看java了，都忘看亲....所以现在也真心不想碰java了。不好意思啊。
 
#23楼 2012-09-13 12:57 AP0906117
@yyg1982
所谓资源共享，就是共享同一个he里的count...
 
#24楼 2012-10-31 16:33 Bactryki
太棒了楼主！
 
#25楼 2012-11-05 16:30 黎明前的曙光
@铁拐李
文中有几处错误的，下面有人指出了，希望博主能够修改错误！
 
#26楼 2012-12-06 11:00 玛卡
@yyg1982
不好意思，点“支持的”，不小心点到"反对"上了，我觉得也是这样的
 
#27楼 2012-12-28 09:45 gray_peng
嗯  不错
 
#28楼 2013-02-04 11:45 人间烟火
对我的帮助很大，谢谢
 
#29楼 2013-02-26 09:19 penkee
这个资源共享的不对
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class MyThread2 extends Thread {
private int ticket= 5 ;
@Override
public void run() {
// TODO Auto-generated method stub
super .run();
for ( int i= 0 ; i<= 20 ; i++) {
if ( this .ticket > 0 ) {
System.out.println(
Thread.currentThread().getName()+ "正在卖票" +
this .ticket--);
}
}
}
}

这一样可以
 
#30楼 2013-03-01 22:56 oo_key
我是多线程的初手，很不错，能看懂，还有什么精彩的文章呀~~~
 
#31楼 2013-03-12 13:03 行者历程
写得很仔细
 
#32楼 2013-03-17 15:38 Akishimo
最后一个看不懂啊555555555555555555
 
#33楼 2013-04-12 18:21 丶蔡
学习了
 
#34楼 2013-04-25 18:44 Mo 。
写的真好！
 
#35楼 2013-04-27 11:00 luofer
唉那个什么实现Runable接口就能共享，连我这没学过java的知道不可能的。就这水平还拿来显摆。误人子弟。
什么时候私有的还非静态的变量能在实例间共享了？
 
#36楼 2670206 2013/5/1 15:27:352013-05-01 15:27 fi$h
实现多线程不止这两种，但主要是这两种
雪山红柳
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java向多线程中传递参数的三种方法详细介绍
09-05
以下将详细介绍三种向Java多线程传递参数的方法。 1. **通过构造方法传递数据** 当创建Thread类或其子类的实例时，可以利用构造方法来传递数据。这些数据通常存储为类的成员变量，在`run()`方法中使用。例如： ``...
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
JAVA多线程详解（超详细）
m0_74823434的博客
10-10 1万+
程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。
java多线程
最新发布
m0_46702681的博客
06-19 1960
javajava。
java多线程详解
xyx328的博客
03-04 1211
多线程的实现方式
一文搞懂Java多线程，讲的很详细，收藏起来慢慢看
兴趣是最好的老师，勤能补拙
07-05 2043
多线程是指在一个程序中同时执行多个线程，每个线程都有自己独立的执行路径。在多线程中，程序的执行可以同时进行多个任务，从而提高系统的资源利用率和响应性能。在传统的单线程编程模型中，程序按照顺序执行，一次只处理一个任务。这种方式在某些情况下可能会导致效率低下或者无法满足需求。而多线程通过将任务拆分为多个子任务，并且在不同的线程上同时执行，从而实现并发处理。
Java基础--多线程详解
a18792721831的博客
06-06 3379
1.线程的概念； 2.线程如何使用； 3.jdk支持的基本线程池； 4.线程生命周期； 5.线程启动与终止； 6.后台线程； 7.线程继承其他类；
Java多线程并发执行demo代码实例
08-18
"Java多线程并发执行demo代码实例" 在Java编程中，多线程并发执行是非常重要的概念，它可以提高程序的执行效率和响应速度。今天，我们通过一个demo代码实例来学习Java多线程并发执行的实现。 知识点1：泛型 在...
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
java中多线程的超详细介绍
08-25
Java中多线程的超详细介绍 Java中的多线程是指在同一个程序中同时执行多个线程的技术。多线程可以提高程序的效率和响应速度，使得程序更加灵活和高效。下面我们将对Java中的多线程进行详细的介绍。 线程概述 线程...
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
JAVA多线程(超详细)
wu_ry的博客
03-10 1824
Thread类提供是了大量的方法来控制和操作过程。Thread类的常用方法如下表所示。Thread类的静态方法currentThread()返回当前线程对象的引用。在java程序启动时，一个线程立即随之启动，这个线程通常被称为程序的主线程。public static void main()方法是主线程的入口，每个进程至少有一个主线程。它的重要性如下。主线程是产生其他子线程的线程。主线程通常必须最后完成运行，因为它执行各种关闭动作。尽管主线程是自动创建的，但是可以由一个Thread对象控制。
Java基础学习——Java线程（一）多线程的发展史、线程的三种创建方式、线程的生命周期、线程的常用方法、线程的优先级
skx1102195517的博客
12-27 1249
一、什么是线程 1.概念 1）程序：为完成特定任务，用某种语言编写的一组指令的集合（程序是静态的） 2）进程：是程序的一次执行过程。进程作为分配资源的单位，在内存中为每个正在运行的进程分配不同的内存区域（进程是动态的），进程有生命周期。 3）线程： 一个进程同时执行多个线程，就是多线程。 2.单核CPU与多核CPU 对于在单核CPU上执行的多个线程，CPU按照时间片执行，一个时间片只能执行一个线程，但时间片时间特别短，造成了同时执行多个线程的假象。 多核CPU才真正实现了同一时间多个线程同时
一篇搞懂Java多线程（全网最细）
让优秀成为一种习惯！
07-22 9560
Java多线程是一种强大而有趣的编程概念。它允许程序同时执行多个任务，就像一个宏大的交响乐团。每个线程都是一个独立的执行路径，有自己的速度和优先级。那么，我们期待多线程能给我们带来什么呢？
Java之多线程（详细总结）
m0_58878709的博客
12-16 803
Java 给多线程编程提供了内置的支持。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
Java多线程（超详解）
m0_52896041的博客
10-26 1万+
Java多线程（超详解）
JAVA之多线程
maxu0808的博客
03-18 2078
一、什么是多线程 1. 线程与进程、并行与并发 进程：每个进程拥有自己的一整套变量。一个进程可以包含多个线程。 线程：线程属于进程，多个线程会存在共享数据的情况发生，也就是多个线程会共享同一块内存区域。 一个例子：打开word是一个进程，打开qq音乐又是另外一个进程，两进程之间不会互相影响（都有自己的一块内存区域）。但比如在qq音乐里一遍听歌，一遍又浏览排行榜，那就是在qq音乐这个进程里又有两个线程，它们之间会存在共享内存的情况。 并发：多线程就是并发的例子，一块CPU调度时会分为好多个时间片，每
java中多线程实现原理
12-16
Java中多线程实现的原理主要是通过线程对象的创建和启动来实现的。Java中实现多线程的方式有四种：继承Thread类、实现Runnable接口、实现Callable接口、使用线程池。下面分别介绍这四种方式的实现原理： 1. 继承Thread类 继承Thread类是实现多线程的一种方式，它的实现原理是创建一个继承自Thread类的子类，并重写run()方法，在run()方法中编写线程执行的代码。然后创建该子类的对象，并调用start()方法启动线程。 2. 实现Runnable接口 实现Runnable接口是实现多线程的另一种方式，它的实现原理是创建一个实现了Runnable接口的类，并实现run()方法，在run()方法中编写线程执行的代码。然后创建该类的对象，并将其作为参数传递给Thread类的构造方法中，最后调用start()方法启动线程。 3. 实现Callable接口 实现Callable接口是实现多线程的一种方式，它的实现原理是创建一个实现了Callable接口的类，并实现call()方法，在call()方法中编写线程执行的代码。然后创建该类的对象，并将其作为参数传递给FutureTask类的构造方法中，最后调用start()方法启动线程。 4. 使用线程池 使用线程池是实现多线程的一种方式，它的实现原理是创建一个线程池对象，并将任务提交给线程池执行。线程池会自动管理线程的创建和销毁，从而避免了频繁创建和销毁线程的开销。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值