Java多线程编程 - 基础篇

最新推荐文章于 2021-10-06 20:26:36 发布
最新推荐文章于 2021-10-06 20:26:36 发布
阅读量845 收藏
点赞数
分类专栏： 面试题集 Java 多线程编程

thanks：http://www.cnblogs.com/rollenholt/archive/2011/08/28/2156357.html


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

1）对于直接继承Thread的类

代码大致框架是：

class 类名 extendsThread{
方法1;
方法2；
…
public void run(){
// other code…
}
属性1；
属性2；
…
 
}


先看一个简单的例子：

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=newhello("A");
        hello h2=newhello("B");
        h1.run();
        h2.run();
    }
 
    privateString name;
}


【运行结果】：

A运行     0

A运行     1

A运行     2

A运行     3

A运行     4

B运行     0

B运行     1

B运行     2

B运行     3

B运行     4

我们会发现这些都是顺序执行的，说明我们的调用方法不对，应该调用的是start（）方法。

当我们把上面的主函数修改为如下所示的时候：

public static void main(String[] args) {
        hello h1=newhello("A");
        hello h2=newhello("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

注意：虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。

那么：为什么我们不能直接调用run（）方法呢？

我的理解是：线程的运行需要本地操作系统的支持。

如果你查看start的源代码的时候，会发现：


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)
            thrownew IllegalThreadStateException();
        group.add(this);
        start0();
        if (stopBeforeStart) {
        stop0(throwableFromStop);
    }
}
private native void start0();

 

注意我用红色加粗的那一条语句，说明此处调用的是start0（）。并且这个这个方法用了native关键字，次关键字表示调用本地操作系统的函数。因为多线程的实现需要本地操作系统的支持。

但是start方法重复调用的话，会出现java.lang.IllegalThreadStateException异常。


2）通过实现Runnable接口：

大致框架是：

class 类名 implementsRunnable{
方法1;
方法2；
…
public void run(){
// other code…
}
属性1；
属性2；
…
 
}

来先看一个小例子吧：

/**
 * 实现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=newhello("线程A");
        Thread demo= newThread(h1);
        hello h2=newhello("线程Ｂ");
        Thread demo1=newThread(h2);
        demo.start();
        demo1.start();
    }
 
    privateString name;
}

【可能的运行结果】

线程A运行     0

线程Ｂ运行     0

线程Ｂ运行     1

线程Ｂ运行     2

线程Ｂ运行     3

线程Ｂ运行     4

线程A运行     1

线程A运行     2

线程A运行     3

线程A运行     4

 

关于选择继承Thread还是实现Runnable接口？

其实Thread也是实现Runnable接口的：

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接口的话，则很容易的实现资源共享。


/**
 * 继承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 = newhello();
        hello h2 = newhello();
        hello h3 = newhello();
        h1.start();
        h2.start();
        h3.start();
    }
 
    privateint 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接口


class MyThread implements Runnable{
 
    privateint 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 = newMyThread();
        newThread(my, "1号窗口").start();
        newThread(my, "2号窗口").start();
        newThread(my, "3号窗口").start();
    }
}


 

　　

【运行结果】：

count= 5

count= 4

count= 3

count= 2

count= 1

 

总结一下：

实现Runnable接口比继承Thread类所具有的优势：

1）：适合多个相同的程序代码的线程去处理同一个资源

2）：可以避免java中的单继承的限制

3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。

 

线程函数的使用：

（1）取得线程的名称

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 = newhello();
        newThread(he,"A").start();
        newThread(he,"B").start();
        newThread(he).start();
    }
}

【运行结果】：

A

A

A

B

B

B

Thread-0

Thread-0

Thread-0

说明如果我们没有指定名字的话，系统自动提供名字。

提醒一下大家：main方法其实也是一个线程。在java中所以的线程都是同时启动的，至于什么时候，哪个先执行，完全看谁先得到CPU的资源。

 

在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个ＪＶＭ，每一个ｊＶＭ实习在就是在操作系统中启动了一个进程。


（2）判断线程是否启动

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 = newhello();
        Thread demo = newThread(he);
        System.out.println("线程启动之前---》"+ demo.isAlive());
        demo.start();
        System.out.println("线程启动之后---》"+ demo.isAlive());
    }
}

【运行结果】

线程启动之前---》false

线程启动之后---》true

Thread-0

Thread-0

Thread-0

主线程也有可能在子线程结束之前结束。并且子线程不受影响，不会因为主线程的结束而结束。

 

（3）线程的强制执行：

 
    
 class hello implements Runnable {
        publicvoid run() {
            for(int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName());
            }
        }
     
        publicstatic void main(String[] args) {
            hello he = newhello();
            Thread demo = newThread(he,"线程");
            demo.start();
            for(inti=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

．．．

 

（4）线程的休眠：

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 = newhello();
        Thread demo = newThread(he, "线程");
        demo.start();
    }
}

【运行结果】：（结果每隔2s输出一个）

线程0

线程1

线程2

 

（5）线程的中断：

  
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 = newhello();
        Thread demo = newThread(he, "线程");
        demo.start();
        try{
            Thread.sleep(2000);
        }catch(Exception e) {
            e.printStackTrace();
        }
        demo.interrupt(); //2s后中断线程
    }
}

【运行结果】：

执行run方法

休眠被打断

在java程序中，只要前台有一个线程在运行，整个java程序进程不会小时，所以此时可以设置一个后台线程，这样即使java进程小时了，此后台线程依然能够继续运行。

?
（6）守护进程： 

class hello implements Runnable {
    public void run() {
        while(true) {
            System.out.println(Thread.currentThread().getName() +"在运行");
        }
    }
 
    public static void main(String[] args) {
        hello he = newhello();
        Thread demo = newThread(he, "线程");
        demo.setDaemon(true);
        demo.start();
    }
}

虽然有一个死循环，但是程序还是可以执行完的。因为在死循环中的线程操作已经设置为后台运行了。


（7）线程的优先级：

class hello implements Runnable {
    public void run() {
        for(inti=0;i<5;++i){
            System.out.println(Thread.currentThread().getName()+"运行"+i);
        }
    }
 
    public static void main(String[] args) {
        Thread h1=newThread(new hello(),"A");
        Thread h2=newThread(new hello(),"B");
        Thread h3=newThread(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.


（8）线程的礼让：

在线程操作中，也可以使用yield（）方法，将一个线程的操作暂时交给其他线程执行。

class hello implements Runnable {
    public void run() {
        for(inti=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=newThread(new hello(),"A");
        Thread h2=newThread(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

 

 

同步和死锁：

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

class hello implements Runnable {
    public void run() {
        for(inti=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=newhello();
        Thread h1=newThread(he);
        Thread h2=newThread(he);
        Thread h3=newThread(he);
        h1.start();
        h2.start();
        h3.start();
    }
    privateint count=5;
}

【运行结果】：

5

4

3

2

1

0

-1

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

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

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

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

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

【同步代码块】：

语法格式：

synchronized（同步对象）{

 //需要同步的代码

}

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

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

?
 
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 方法返回类型方法名（参数列表）{

    // 其他代码

}

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

 
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;
     }
 
     publicsynchronized void set(String name, intage){
         this .name=name;
         try {
             Thread.sleep( 100 );
         } catch (Exception e) {
             e.printStackTrace();
         }
         this .age=age;
     }
     
     publicsynchronized 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;
     }
 
     publicsynchronized void set(String name, intage){
         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


先在看结果就可以知道，之前的问题完全解决


学习。共勉。

绝杀fc小飞侠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
指令级别解释对象创建过程和DCL为什么要volatile
weixin_39370859的博客
03-14 197
先上图 先明白几点 1.jvm stack指的是线程栈，一个线程有一个jvm stack。 2.线程里的一个方法对应一个栈帧，一个栈帧有Local Variables（本地变量表，记录了方法的参数、局部变量）、Operand Stacks（方法运算的变量引用，常量值需要压栈和弹栈）、Dynamic Linking（方法运算需要引用方法区的引用）、Return Address（记录了方法需要返回的调用者的地址）。 3.所有方法栈里的运算都要压栈和弹栈，就是Operand Stacks要频繁的发生 astor
Java并发编程——多线程基础
AlexTuringGong的博客
01-14 90
文章目录创建线程的方法继承Thread类实现runnable接口实现Callable接口终止线程中断线程线程通信线程限流 创建线程的方法 继承Thread类 构造一个内部类，继承thread类，然后重写run()方法。 如果需要用到共享数据，那么必须是静态属性； 举例：thread\ThreadTest.java，thread\Window2.java 实现runnable接口 过程： 1.创建一个类实现runnable接口； 2.创建这个类的对象； 3.把这个对象作为参数，新建一个Thread类的对象；
java创建对象方案_java创建对象的四种方式
weixin_42362146的博客
02-25 118
1.使用new创建对象使用new关键字创建对象应该是最常见的一种方式，但我们应该知道，使用new创建对象会增加耦合度。无论使用什么框架，都要减少new的使用以降低耦合度。1 packageyunche.test;23 public classHello {4 public voidsayWorld() {5 System.out.println("Hello world!"...
内部类
blake2的博客
12-17 103
内部类 6.1.什么是内部类？ 将一个java类定义到另一个java类中的java类就是内部类。 外部类---包含内部类的类。 内部类---外部类中的类。 内部类编译后会形成一个新的字节码文件【外部类类名$内部类类型.class】 6.2.内部类有几种表现形式分别都是如何编写的？每一种内部类各自都有哪些特征？ 1、成员内部类--类中方法外【成员变量】 例如: package com.wangxing.test1; //外部类 ...
java 构造方法要点整理
qq_29439415的博客
10-06 120
java执行系统默认的构造方法时会给所有参数赋值为0或null 如果构建了带参数的构造方法 , 同样要定义<对象名>() , 也就是空参的构造方法 , 否则会产生错误 在同一类下重载构造方法时可以用 : this(<参数>)来替代 public class hello { int value; String str; public static void main(String[] args) { hello h = new hello(1); h
Java 多线程编程
红叶岭谷的博客
05-12 467
Java 多线程编程 Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程，并且每个线程定义了一个独立的执行路径。 多线程是多任务的一种特别的形式。多线程比多任务需要更小的开销。 这里定义和线程相关的另一个术语：进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。
读书笔记-Java并发编程实战-基础篇
08-09
读书笔记-Java并发编程实战-基础篇
java多线程编程实战指南 核心篇 代码
02-20
随着现代处理器的生产工艺从提升...《Java多线程编程实战指南（核心篇）》适合有一定Java语言基础的读者作为入门多线程编程之用，也适合有一定多线程编程经验的读者作为重新梳理知识结构以提升认知层次和参考之用。
Java多线程编程实战指南-设计模式篇
04-19
随着CPU 多核时代的到来，多线程编程在充分利用计算资源、提高软件服务质量方面扮演了越来越重要的角色。...《Java多线程编程实战指南（设计模式篇）》适合有一定Java 多线程编程基础、经验的读者。
多线程编程实战指南-核心篇
07-16
总之，《多线程编程实战指南-核心篇》是一本全面解析Java多线程编程的书籍，通过学习，开发者不仅可以掌握多线程编程的基本原理，还能学会如何在实际项目中应用这些知识，提升程序的并发性能和稳定性。对于有一定...
java 多线程编程实战指南（核心 + 设计模式 完整版）
03-20
《Java多线程编程实战指南》这本书深入浅出地讲解了Java多线程的核心概念和实战技巧，分为核心篇和设计模式篇，旨在帮助开发者掌握并应用多线程技术。 1. **线程基础** - **线程的创建**：Java提供了两种创建线程...
前端分析-202307110039
07-29
前端分析-202307110039
Oracle中文基础PPT
07-29
Oracle中文基础PPT 虽然是10g，但是学习Oracle，10g版本没问题 Less01_DB_Architecture_MB3.ppt Less02_Installation_MB3.ppt Less03_DB_DBCA_MB3.ppt Less04_Instance_TB3.ppt Less05_Storage_TB3.ppt Less06_Users_MB3.ppt Less07_Schema_TB3.ppt Less08_Data_TB3.ppt Less09_Undo_TB3.ppt Less10_Security_MB3.ppt Less11_Network_MB3.ppt Less12_ProactiveM_MB3.ppt Less13_Performance_TB3.ppt Less14_BR_Concepts_MB3.ppt Less15_Backups_TB3.ppt Less16_R
【创新未发表】Matlab实现粒子群优化算法PSO-Kmean-Transformer-BiLSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
Java项目：基于SSM框架实现的公务员培训机构管理系统【ssm+B/S架构+源码+数据库+开题+任务书+毕业论文】
07-29
一、项目简介 本项目是一套基于SSM框架实现的公务员培训机构管理系统 包含：项目源码、数据库脚本等，该项目附带全部源码可作为毕设使用。 项目都经过严格调试，eclipse或者idea 确保可以运行！ 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值 二、技术实现 jdk版本：1.8 及以上 ide工具：IDEA或者eclipse 数据库: mysql5.7 后端：spring+springmvc+mybatis+maven+mysql 前端：jsp，css，js 三、系统功能 系统登录角色包括管理员、考生、在职公务员 后台主要功能包括： 个人中心 修改密码 个人信息 在职公务员管理 考生管理 管理员信息 讲师管理 备考课程管理 基础数据管理 单位管理 公告类型管理 课程类型管理 在职培训课程管理 公告管理 轮播图管理等功能 前台主要功能包括： 用户登录 用户注册 首页 备考课程展示 课程详情 立即预订 讲师展示 公告信息 个人中心 备考课程预订 在职培训课程预订 余额充值 在职培训课程 跳转到后台等功能
Auto.js应用管理大师：自动化安装与卸载的艺术
07-29
Auto.js 是一个基于 JavaScript 的自动化脚本工具，主要用于 Android 平台。它允许用户编写脚本来自动执行一系列操作，如模拟点击、滑动、输入文本、读取和设置系统设置等。Auto.js 的目标是简化 Android 设备上的自动化任务，让用户能够通过编写脚本来实现自定义的自动化流程。 以下是 Auto.js 的一些主要特点： 1. **跨平台**：虽然主要针对 Android，但 Auto.js 也可以在其他支持 JavaScript 运行环境的平台上使用。 2. **易学易用**：如果你熟悉 JavaScript，那么学习 Auto.js 会相对容易，因为它使用类似的语法。 3. **丰富的API**：Auto.js 提供了丰富的 API，可以访问设备的许多功能，如文件系统、剪贴板、通知、网络等。 4. **社区支持**：Auto.js 拥有一个活跃的社区，用户可以在社区中分享脚本、解决问题和获取帮助。 5. **可扩展性**：用户可以根据自己的需要编写和分享自定义模块，以扩展 Auto.js 的功能。 6. **自动化任务**：Auto.js 可以用来自动化
单片机控制的节水灌溉系统的研究
07-29
自动控制节水灌溉技术的高低代表着农业现代化的发展状况，灌溉系统自动化水平较低是制约我国高效农业发展的主要原因。本文就此问题研究了单片机控制的滴灌节水灌溉系统，该系统可对不同土壤的湿度进行监控，并按照作物对土壤湿度的要求进行适时、适量灌水，其核心是单片机和PC机构成的控制部分，主要对土壤湿度与灌水量之间的关系、灌溉控制技术及设备系统的硬件、软件编程各个部分进行了深入的研究。 单片机控制部分采用上下位机的形式。下位机硬件部分选用AT89C51单片机为核心，主要由土壤湿度传感器，信号处理电路，显示电路，输出控制电路，故障报警电路等组成，软件选用汇编语言编程。上位机选用586型以上PC机，通过MAX232芯片实现同下位机的电平转换功能，上下位机之间通过串行通信方式进行数据的双向传输，软件选用VB高级编程语言以建立友好的人机界面。系统主要具有以下功能：可在PC机提供的人机对话界面上设置作物要求的土壤湿度相关参数；单片机可将土壤湿度传感器检测到的土壤湿度模拟量转换成数字量，显示于LED显示器上，同时单片机可采用串行通信方式将此湿度值传输到PC机上；PC机通过其内设程序计算出所需的灌水量和灌水时间，且显示于界面上，并将有关的灌水信息反馈给单片机，若需灌水，则单片机系统启动鸣音报警，发出灌水信号，并经放大驱动设备，开启电磁阀进行倒计时定时灌水，若不需灌水，即PC机上显示的灌水量和灌水时间均为0,系统不进行灌水。
人工蜂群算法(ABC)优化支持向量机的数据分类预测，ABC-SVM分类预测，多变量输入模型 多特征输入单输出的二分类及多分类
07-29
人工蜂群算法(ABC)优化支持向量机的数据分类预测，ABC-SVM分类预测，多变量输入模型。 多特征输入单输出的二分类及多分类模型。程序内注释详细，直接替换数据就可以用。 程序语言为matlab，程序可出分类效果图，迭代优化图，混淆矩阵图。
基于 python 的航空发动机燃油热管理仿真软件开发
最新发布
07-29
针对航空发动机综合热管理系统不断提升的仿真需求，利用 T[6AF. 编程语言开发了航空发 动机燃油热管理仿真软件!首先，基于工程热力学和流体力学原理，建立了常见燃油系统部件 ( 如管路"泵和换热器等) 的数学模型!其次，采用 T[d6 库进行了图形用户界面的设计，包括组件 区"仿真区和计算显示区等; 同时建立了 ROH^A,E- Q,@C 仿真框架，并设计了元件类和线条类分别 表示部件及其关系，实现了对燃油系统的交互式仿真; 此外，建立代表部件数学模型的计算类以 进行数值仿真计算!最后，搭建了简化的燃油回路模型并进行仿真分析，验证了软件的有效性!
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值