黑马程序员——java中的多线程(二)

最新推荐文章于 2024-07-14 13:21:09 发布
最新推荐文章于 2024-07-14 13:21:09 发布
阅读量314 收藏
点赞数
分类专栏： 知识总结 文章标签： java 多线程 线程 黑马程序员

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------



在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

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

 

那么如何解决呢？

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
先在看结果就可以知道，之前的问题完全解决。



libooy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员——java多线程
serge666的博客
12-12 349
——- android培训、java培训、期待与您交流！ ———-什么是进程？ Ctrl+Shift+Esc 打开windows任务管理器 进程是操作系统动态执行和资源分配的一个基本单元，就是程序执行的过程，在这个过程中会占用内存空间和CPU资源。在操作系统中，程序的体现就是进程。一个程序至少有一个进程，一个复杂的应用程序可能启动并使用多个进程，例如谷歌Chrome浏览器、腾讯的QQ等采用的就是多
黑马程序员——java的多线程
hgdswj的博客
06-27 541
------- android培训、java培训、期待与您交流！ ---------- 前言：通过观看毕向东老师的java基础视频，查漏补缺，将一些自己掌握的还不牢固的知识写出来，希望和大家交流分享。 一、进程与线程        进程：正在执行的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。        线程：把进程中的功能分成各个部分，每个部分有一个
黑马程序员——Java多线程
daiqingmingg的博客
10-19 329
------http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一 . 线程和进程       进程：一个内存中运行的程序       线程：（1）线程是为了实现多任务，提供效率而出现的一个产物。进程中的一个执行流程，一个进程中可以运行                
黑马程序员————Java多线程技术详解
瑞雪的博客
10-02 602
本文讲解了线程的基础知识，线程同步，锁机制，线程池等方面的知识
黑马程序员——Java中 多线程笔记
bayueqinglian的专栏
06-28 380
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 一、多线程概述 进程：正在运行的程序，是系统进行资源分配和调用的独立单位。  每一个进程都有它自己的内存空间和系统资源。       线程：是进程中的单个顺序控制流，是一条执行路径  一个进程如果只有一条执行路径，则称为单线程程序。  一个进程如果有多条执行
黑马程序员——java基础之多线程
back
01-02 493
——- android培训、java培训、期待与您交流！ ———-java基础之多线程一. 多线程的概念1. 进程、线程和多线程： 进程：正在进行中的程序（直译）。进程是程序在某个数据集上的运行，它有自己的生命周期，因调度而运行。因等待资源或事件而被处于等待状态，因完成任务而被撤销。 线程：进程中一个负责程序执行的控制单元（执行路径）。是一个程序中的不同执行路径。一个进程中可以有多个执行路径，称之为
黑马程序员——Java继承——多线程（二）
maidou51的博客
11-18 338
本人习惯将总结写在代码里~ 线程间通信问题： package cn.fuxi.duoxiancheng2; /** * 线程间通信 * 多线程在处理统一资源,但是任务却不同,这时候就需要线程间通信. * 等待/唤醒机制涉及的方法: * 1.wait():让线程处于冻结状态,被wait的线程会被存储到线程池中. * 2.notify():唤醒线程池中的一个线程(任何一个都有可能).
黑马程序员——Java（多线程）
u013275794的专栏
12-29 328
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1）进程： 是一个正在执行中的程序。 每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。 （2）线程： 就是进程中的一个独立的控制单元。 线程在控制着进程的执行。一个进程中至少有一个线程。 java中体现：java JVM启动的时候，会有一个
黑马程序员——Java中多线程技术
wanyy的博客
08-10 253
------Java培训、Android培训、期待与您交流！ ------- 一、多线程概念     学习多线程首先需要掌握一些基本概念：   1、进程     进程是指一个正在运行的程序，它经历了从代码加载、执行到执行完毕的整个过程，每个进程都有自己独立的一块内存空间，多进程操作系统可以同时运行多个进程。 2、线程 线程是指进程中一个负责程序执行的控制单
黑马程序员入学Java知识——精华总结.doc
05-09
Java内置了对多线程的支持，通过Thread类或实现Runnable接口可以创建并管理多个执行线程。 17. **网络编程**： Java提供了丰富的API进行网络通信，如Socket和ServerSocket类，用于客户端和服务器之间的连接。 ...
黑马程序员入学Java知识——精华总结
03-07
"黑马程序员入学Java知识——精华总结"这份文档很可能包含了Java编程的基础到进阶的知识点，旨在帮助初学者快速掌握Java的核心概念和技能。 1. **Java基础知识**：Java是一种面向对象的语言，它的基础包括语法、...
黑马程序员_(适合初学者入门的Java基础视频)
08-24
"黑马程序员_（适合初学者入门的Java基础视频）"是一套专为初学者设计的Java基础教学课程，旨在帮助零基础的学习者逐步掌握Java编程的基本概念和技能。 该视频教程涵盖了Java的基础知识，包括： 1. **环境搭建**：...
黑马程序员 安卓学院 万元哥项目经理 分享220个代码实例
10-07
|--利用FinalHttp实现多线程断点续传 |--加密之MD5 |--动画Animation详解 |--动画之view左右抖动 |--动画之移动动画 |--动画之组合动画 |--动画之缩放动画ScaleAnimation |--反序列化对象 |--发送短信 读天气 调音量...
2018-2019年黑马最新版Java程序员面试宝典+题库pdf
03-26
《2018-2019年黑马最新版Java程序员面试宝典+题库pdf》是一份集合了近年来Java编程领域重点知识和面试常见问题的综合资源。这份资料主要针对初级Java程序员，旨在帮助他们巩固基础知识，掌握面试技巧，以便在求职...
配置Java开发环境
Broken_x的博客
07-10 1545
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 516
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
【Go系列】 Sync并发控制
最新发布
u013379032的博客
07-14 625
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
Java方法练习-双色球彩票系统
T1798218285的博客
07-11 279
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
黑马程序员多线程练习题
08-23
- *1* *2* *3* [黑马程序员——多线程10：多线程相关练习](https://blog.csdn.net/axr1985lazy/article/details/48186039)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值