170306网络编程线程

Posted 2020-09-02 菜鸟有觉悟要努力了

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了170306网络编程线程相关的知识，希望对你有一定的参考价值。

一.线程的控制举例 and 简单界面实现计时功能

 1 package runnable;
 2 
 3 import java.awt.GridLayout;
 4 import java.awt.event.*;
 5 import java.util.Date;
 6 
 7 import javax.swing.*;
 8 
 9 public class ControlThreadDemo extends JFrame{
10     
11     JLabel jlb1;
12     JButton jb1,jb2;
13     JPanel jp1;
14     Thread thread1;
15     boolean isExit=false;
16     
17     public ControlThreadDemo(){
18         this.setLocation(100,100);
19         this.setSize(300,300);
20         this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
21         this.setLayout(new GridLayout(2,1));//两行一列
22         
23         jp1=new JPanel();
24         jb1=new JButton("启动");
25         jlb1=new JLabel("显示当前时间");
26         this.add(jlb1);
27         //添加监听器
28         jb1.addActionListener(new ActionListener(){
29 
30             @Override
31             public void actionPerformed(ActionEvent arg0) {
32                 // TODO Auto-generated method stub
33                 thread1=new Thread(new Runnable(){
34 
35                     @Override
36                     public void run() {
37                         // TODO Auto-generated method stub
38                         //获取当前时间 的字符串    date
39                         while(!isExit){
40                             jlb1.setText("当前时间为："+new Date().toString());
41                             try {
42                                 Thread.sleep(1000);//1秒
43                             } catch (InterruptedException e) {
44                                 // TODO Auto-generated catch block
45                                 e.printStackTrace();
46                             }
47                         }
48                         
49                     
50                         
51                     }
52                     
53                 });
54                 thread1.start();
55             }
56             
57         });
58 //        
59         
60         jb2=new JButton("停止");
61         //添加监听器
62         jb2.addActionListener(new ActionListener(){
63 
64             @Override
65             public void actionPerformed(ActionEvent arg0) {
66                 
67                         // TODO Auto-generated method stub
68                         //获取当前时间 的字符串    date
69                         // TODO Auto-generated method stub
70                 
71                 //这个已经out了
72 //                        if(thread1.isAlive()){
73 //
74 //                            thread1.stop();
75 //                        }
76                 
77                 isExit=true;
78                     
79                 }
80         
81         });
82         
83         jp1.add(jb1);
84         jp1.add(jb2);
85         this.add(jp1);
86         
87         this.setVisible(true);
88                 
89     }
90     
91     
92     //在java中，一个进程至少有一个线程，该线程会执行main函数的代码，执行main函数代码的线程叫主线程
93     public static void main(String[]args){
94         new ControlThreadDemo();
95     }
96 
97 }

二.面向方法的Synthronize

 1 package runnable;
 2 
 3 public class SynthronizeDemo {
 4     
 5     static int count=0;
 6     
 7     //在java中，一个进程至少有一个线程，该线程会执行main函数的代码，执行main函数代码的线程叫主线程
 8     public static void main(String[]args){
 9         
10         System.out.println("这段代码是被主线程执行的！！！！");  
11     
12         //对方法同步
13         new Thread(new Runnable(){
14 
15             @Override
16             public void run() {
17                 // TODO Auto-generated method stub
18                 for(int i=0;i<10;i++){
19                     add(true);
20                     try {
21                         Thread.sleep(1000);
22                     } catch (InterruptedException e) {
23                         // TODO Auto-generated catch block
24                         e.printStackTrace();
25                     }
26                 }
27                     
28             }
29             
30         }).start();
31         
32         
33         new Thread(new Runnable(){
34 
35             @Override
36             public void run() {
37                 // TODO Auto-generated method stub
38                 for(int i=0;i<10;i++){
39                     add(false);
40                     try {
41                         Thread.sleep(1000);
42                     } catch (InterruptedException e) {
43                         // TODO Auto-generated catch block
44                         e.printStackTrace();
45                     }
46                 }            
47             }    
48         }).start();
49         
50     }
51     
52     //Synthronize相当于给函数加了一把锁，只许一个访问
53     //给方法add加一把同步锁，实现add方法对所有线程的同步
54     public static synchronized void add(boolean flag){
55         count++;
56         if(flag){
57             System.out.print("1");
58             System.out.println("第一个线程进来了，当前count的值 为："+count);
59         }else{
60             System.out.print("2");
61             System.out.println("第二个线程进来了，当前count的值 为："+count);
62         }
63     }    
64     
65 }

三.面向对象的Synthronize（这段代码和上一段代码其实效果是一样的）

 1 package runnable;
 2 
 3 public class SynthronizeDemo1 {
 4     
 5     static int count=0;
 6     //定义一个对象，利用该对象实现线程同步
 7     static Object obj=new Object();
 8     
 9     //在java中，一个进程至少有一个线程，该线程会执行main函数的代码，执行main函数代码的线程叫主线程
10     public static void main(String[]args){
11         System.out.println("这段代码是被主线程执行的！！！！"); 
12         
13         //对方法同步
14         new Thread(new Runnable(){
15 
16             @Override
17             public void run() {
18                 // TODO Auto-generated method stub
19                 for(int i=0;i<10;i++){
20                     add(true);
21                     try {
22                         Thread.sleep(1000);
23                     } catch (InterruptedException e) {
24                         // TODO Auto-generated catch block
25                         e.printStackTrace();
26                     }
27                 }
28                     
29             }
30             
31         }).start();
32         
33         
34         new Thread(new Runnable(){
35 
36             @Override
37             public void run() {
38                 // TODO Auto-generated method stub
39                 for(int i=0;i<10;i++){
40                     add(false);
41                     try {
42                         Thread.sleep(1000);
43                     } catch (InterruptedException e) {
44                         // TODO Auto-generated catch block
45                         e.printStackTrace();
46                     }
47                 }
48                     
49             }
50             
51         }).start();
52     }
53     
54     public static void add(boolean flag){
55         //对obj对象同步，也就是在同一时刻，只有一个线程会执行后面{}里面的代码
56         synchronized(obj){
57             count++;
58             if(flag){
59                 System.out.print("1");
60                 System.out.println("第一个线程进来了，当前count的值 为："+count);
61             }else{
62                 System.out.print("2");
63                 System.out.println("第二个线程进来了，当前count的值 为："+count);
64             }
65         }
66     }    
67     
68 }

四.窗体+显示坐标监听器

 1 package runnable;
 2 
 3 import java.awt.FlowLayout;
 4 import java.awt.event.ActionEvent;
 5 import java.awt.event.ActionListener;
 6 import java.awt.event.MouseEvent;
 7 import java.awt.event.MouseMotionListener;
 8 import java.awt.event.WindowAdapter;
 9 
10 import javax.swing.*;
11 
12 public class yy extends JFrame{
13     JButton jb1;
14     JLabel jlb1;
15     public yy(){
16         this.setLocation(100,100);
17         this.setSize(500, 500);
18         this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);//啥意思,用户单击窗口的关闭按钮时程序执行的操作
19         
20         jb1=new JButton("c s ");
21         jlb1=new JLabel();
22         
23         jb1.addActionListener(new ActionListener(){
24 
25             @Override
26             public void actionPerformed(ActionEvent arg0) {
27                 // TODO Auto-generated method stub
28                 System.out.println("hello zhbit");
29             }
30         });
31         
32         this.add(jb1);
33         this.add(jlb1);
34         this.setLayout(new FlowLayout());
35         
36         this.addMouseMotionListener(new MouseMotionListener(){
37 
38             @Override
39             public void mouseDragged(MouseEvent arg0) {
40                 // TODO Auto-generated method stub
41                 
42             }
43 
44             @Override
45             public void mouseMoved(MouseEvent arg0) {
46                 // TODO Auto-generated method stub
47                 int x=arg0.getX();
48                 int y=arg0.getY();
49                 jlb1.setText("x= "+x+"  y= "+y);
50             }
51             
52         });
53         this.addWindowListener(new MyWindowsListener());
54         
55         this.setVisible(true);
56     }
57     
58     public static void main(String[]args){
59         new yy();
60     }
61     class MyWindowsListener extends WindowAdapter{
62         
63     }
64 
65 }

五.1使用外部类定义Thread

 1 package runnable;
 2 
 3 public class ThreadDemo {
 4     
 5     //在java中，一个进程至少有一个线程，该线程会执行main函数的代码，执行main函数代码的线程叫主线程
 6     public static void main(String[]args){
 7         
 8         System.out.println("这段代码是被主线程执行的！！！！");
 9         //（3）创建线程类的对象
10         MyThread myThread=new MyThread();
11         
12         //（4）启动该线程，该线程启动后会执行run函数
13         myThread.start();
14     }
15 }
16 //外部类
17 //利用Thread类来创建线程的步骤：（1）定义一个类继承Thread类
18 class MyThread extends Thread{
19 
20     //（2）重写Thread类中的run方法
21     @Override
22     public void run() {
23         // TODO Auto-generated method stub
24         for(int i=0;i<10;i++){
25             System.out.println("这段代码被子进程执行！");
26             try {
27                 Thread.sleep(1000);//让当前线程休息一秒
28             } catch (InterruptedException e) {
29                 // TODO Auto-generated catch block
30                 e.printStackTrace();
31             }
32         }
33     }
34 }

五.2使用匿名类定义Thread

 1 package runnable;
 2 
 3 public class ThreadDemo {
 4     
 5     //在java中，一个进程至少有一个线程，该线程会执行main函数的代码，执行main函数代码的线程叫主线程
 6     public static void main(String[]args){
 7         
 8         System.out.println("这段代码是被主线程执行的！！！！");
 9         /*//（3）创建线程类的对象
10         MyThread myThread=new MyThread();
11         
12         //（4）启动该线程，该线程启动后会执行run函数
13         myThread.start();*/
14         
15         new Thread(){
16             public void run() {
17                 // TODO Auto-generated method stub
18                 for(int i=0;i<10;i++){
19                     System.out.println("这段代码被子进程执行！");
20                     try {
21                         Thread.sleep(1000);//让当前线程休息一秒
22                     } catch (InterruptedException e) {
23                         // TODO Auto-generated catch block
24                         e.printStackTrace();
25                     }
26                 }
27             }
28         }.start();
29     }
30 }
31 //外部类
32 //利用Thread类来创建线程的步骤：（1）定义一个类继承Thread类
33 /*class MyThread extends Thread{
34 
35     //（2）重写Thread类中的run方法
36     @Override
37     public void run() {
38         // TODO Auto-generated method stub
39         for(int i=0;i<10;i++){
40             System.out.println("这段代码被子进程执行！");
41             try {
42                 Thread.sleep(1000);//让当前线程休息一秒
43             } catch (InterruptedException e) {
44                 // TODO Auto-generated catch block
45                 e.printStackTrace();
46             }
47         }
48     }
49 }*/

六.1使用外部类使用Runnable接口

//??runnable和thread的区别,在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread///类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。

 1 package runnable;
 2 
 3 //??runnable和thread的区别
 4 
 5 public class ThreadDemo1 {
 6     
 7     //在java中，一个进程至少有一个线程，该线程会执行main函数的代码，执行main函数代码的线程叫主线程
 8     public static void main(String[]args){
 9         
10         System.out.println("这段代码是被主线程执行的！！！！");
11     
12         //（3）创建实现了Runnable接口类的对象
13         MyRunnable myRunnable=new MyRunnable();
14         
15         //（4）创建线程对象，并传入myRunnable对象
16         Thread myThread=new Thread(myRunnable);
17         
18         //（5）启动该线程
19         myThread.start();
20 
21     }
22 }
23 
24 //外部类
25 //利用Runnable接口来创建线程的步骤：（1）定义一个类实现Runnable接口
26 class MyRunnable implements Runnable{
27 
28     //（2）重写Runnable接口中的run方法
29     @Override
30     public void run() {
31         // TODO Auto-generated method stub
32         for(int i=0;i<10;i++){
33             System.out.println("这段代码被子进程执行！");
34             try {
35                 Thread.sleep(1000);//让当前线程休息一秒
36             } catch (InterruptedException e) {
37                 // TODO Auto-generated catch block
38                 e.printStackTrace();
39             }
40         }
41     }
42 }

六.2使用匿名类使用Runnable接口

 1 package runnable;
 2 
 3 //??runnable和thread的区别,在java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口；Thread类是在java.lang包中定义的。一个类只要继承了Thread///类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。
 4 
 5 public class ThreadDemo1 {
 6     
 7     //在java中，一个进程至少有一个线程，该线程会执行main函数的代码，执行main函数代码的线程叫主线程
 8     public static void main(String[]args){
 9         
10         System.out.println("这段代码是被主线程执行的！！！！");
11     
12         new Thread(new Runnable(){
13             public void run() {
14         // TODO Auto-generated method stub
15                 for(int i=0;i<10;i++){
16                     System.out.println("这段代码被子进程执行！");
17                     try {
18                         Thread.sleep(1000);//让当前线程休息一秒
19                     } catch (InterruptedException e) {
20                         // TODO Auto-generated catch block
21                         e.printStackTrace();
22                     }
23                 }
24             }
25         }).start();;
26     }
27 }

以上是关于170306网络编程线程的主要内容，如果未能解决你的问题，请参考以下文章

JUC并发编程共享模式之工具 JUC CountdownLatch（倒计时锁） -- CountdownLatch应用（等待多个线程准备完毕（可以覆盖上次的打印内）等待多个远程调用结束）(代码片段

多线程编程

newCacheThreadPool()newFixedThreadPool()newScheduledThreadPool()newSingleThreadExecutor()自定义线程池(代码片段

python中的多线程和多进程编程

多线程 Thread 线程同步 synchronized