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 }

时间： 2024-10-12 22:55:17

170306网络编程线程的相关文章

Java网络编程线程

线程作用当服务器需要大量并发连接的时候,一般使用轻量级的线程来处理大量的连接,而不是重量级的进程.线程在资源使用上更宽松,因为它们会共享内存.使用线程来代替进程,可以再让你的服务器性能提升三倍.再结合使用可重用的线程池,在同样的硬件和网络连接下,服务器的运行可以快9倍多!采用多线程设计设计会更容易,可以将程序分解为多个线程,分别执行独立的操作. 由于现代虚拟机和操作系统中线程可以提供很高的性能,而且构建基于线程的服务器相对简单,所以开始时总会考虑采用基于线程的设计.如果确实遇到麻烦,应该考虑将

python网络编程--线程(锁,GIL锁,守护线程)

1.线程 1.进程与线程进程有很多优点,它提供了多道编程,让我们感觉我们每个人都拥有自己的CPU和其他资源,可以提高计算机的利用率.很多人就不理解了,既然进程这么优秀,为什么还要线程呢?其实,仔细观察就会发现进程还是有很多缺陷的,主要体现在两点上: 进程只能在一个时间干一件事,如果想同时干两件事或多件事,进程就无能为力了. 进程在执行的过程中如果阻塞,例如等待输入,整个进程就会挂起,即使进程中有些工作不依赖于输入的数据,也将无法执行. 如果这两个缺点理解比较困难的话,举个现实的例子也许你就清楚

linux网络编程----->线程同步一

开发使用多线程过程中, 不可避免的会出现多个线程同时操作同一块共享资源, 当操作全部为读时, 不会出现未知结果, 一旦当某个线程操作中有写操作时, 就会出现数据不同步的事件. 而出现数据混乱的原因: 资源共享(独享资源则不会) 调试随机(对数据的访问会出现竞争) 线程间缺少必要的同步机制以上三点, 前两点不能被改变. 欲提高效率, 传递数据, 资源必须共享. 只要资源共享, 就一定会出现线程间资源竞争, 只要存在竞争关系, 数据就会出现混乱. 所以只能从第三点着手, 使多个线程在访问共享资源的

两种unix网络编程线程池的设计方法

unp27章节中的27.12中,我们的子线程是通过操作共享任务缓冲区,得到task的,也就是通过线程间共享的clifd[]数组,这个数组其实就是我们的任务数组,得到其中的connfd资源. 我们对这个任务数组的操作,需要互斥量+条件变量达到同步的目的..每个线程是无规律的从clifd得到任务,然后执行的.任务和线程之间没有对应关系.线程完成本次任务之后,如果任务数组中任然有任务,则再次运行下一个任务. 而另外的一个线程池模型中,pthread_create (&temp[i].tid, NULL

linux网络编程----->线程同步-->信号量

linux网络编程----->线程同步-->条件变量

linux网络编程----->线程死锁

12、第七周-网络编程 - 线程中的信号量(Semaphore)

互斥锁同时只允许一个线程更改数据,而Semaphore是同时允许一定数量的线程更改数据.简单介绍如下: 信号量用在多线程多任务同步的,一个线程完成了某一个动作就通过信号量告诉别的线程,别的线程再进行某些动作.而互斥锁是用在多线程多任务互斥的,一个线程占用了某一个资源,那么别的线程就无法访问,直到这个线程unlock,其他的线程才开始可以利用这个资源.比如对全局变量的访问,有时要加锁,操作完了,在解锁.有的时候锁和信号量会同时使用的. 也就是说,信号量不一定是锁定某一个资源,而是流程上的概念,比

网络编程-线程-3、通过继承Thread类创建线程

知识点:之前第一节介绍创建线程的方法是:通过threading.Thread(target=函数名不要加括号)创建一个对象,通过对象调用start方法创建并启动线程: 这一节介绍另外一种创建线程的方法:写一个子类,继承Thread类,里面定义一个run方法即可通过该子类创建一个线程代码如下,解释看注解: #!/usr/bin/env python # co