Java学习---多线程的学习

基础知识

每个正在系统上运行的程序都是一个进程(process)。每个进程包含一到多个线程(thread)。进程也可能是整个程序或者是部分程序的动态执行。

线程是一组指令的集合,或者是程序的特殊段,它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程,它负责在单个程序里执行多任务。

Java对多线程的支持是非常强大的,他屏蔽掉了许多的技术细节,让我们可以轻松的开发多线程的应用程序。Java里面有2个方法实现多线程,

1 继承 Thread类,比如
  class MyThread extends Thread {
    public void run() {
    // 这里写上线程的内容
    }
    public static void main(String[] args) {
      // 使用这个方法启动一个线程
      new MyThread().start();
    }
  }
  2 实现 Runnable接口,例如
  class MyThread implements Runnable{
    public void run() {
    // 这里写上线程的内容
    }
    public static void main(String[] args) {
      // 使用这个方法启动一个线程
      new Thread(new MyThread()).start();
    }
  }
一般鼓励使用第二种方法,因为Java里面只允许单一继承,但允许实现多个接口。第二个方法更加灵活。

代码示例

多线程实现1-30的累计,其中共享资源池为1-30的数字的递增,采用了同步锁synchronized。

 1 class Sum{ //共享资源,计数器count
 2     private int count;//共享资源
 3     public int add(){
 4         synchronized(this){ //代码段1,共享锁,修饰程序段或者方法
 5             count = count + 1;
 6             System.out.println("add:" + count);
 7             return count;
 8         }
 9     }
10 }
11 class SumThread implements Runnable{//定义线程
12     private Sum sd;
13     private int sum = 0;
14     private    int [] a = new int[10];
15
16     public SumThread(String name, Sum sd){
17         super(name);
18         this.sd = sd;
19     }
20     public void run(){//必需的重写
21         try{
22             for(int i=0;i<10;i++){
23                 a[i] = sd.add();
24                 sum += a[i];
25                 Thread.sleep(100);
26             }
27             Thread.sleep(1000);
28         }catch(Exception e){}
29
30         System.out.println(getName() + "累加和:" + sum);
31     }
32     public void showData(){
33         System.out.print(getName() + "获得的数为");
34         for(int i=0;i<10;i++){
35             if(i%10==0)System.out.println();
36             System.out.print(a[i] + "+\t");
37         }
38     }
39     public int getSum(){
40         return sum;
41     }
42 }
43 public class SumDemo{
44     public static void main(String [] args){
45         Sum sd = new Sum();//代表共享资源的变量
46         SumThread s1 = new SumThread("线程1",sd);//创建完毕
47         SumThread s2 = new SumThread("线程2",sd);
48         SumThread s3 = new SumThread("线程3",sd);
49         Thread st1 = new Thread(s1);
50         Thread st2 = new Thread(s2);
51         Thread st3 = new Thread(s3);
52         st1.setPriority(Thread.MAX_PRIORITY);  //代码段2
53         st2.setPriority(10);
54         st3.setPriority(1);
55          long begin = System.currentTimeMillis();
56         st1.start();//使线程运行
57         st2.start();        st3.start();
58         St1.join();  st2.join();  st3.join();
59         st1.showData();
60         st2.showData();
61         st3.showData();
62         System.out.println("总和为:" + (st1.getSum() + st2.getSum() + st3.getSum()));
63          long end = System.currentTimeMillis();
64          System.out.println(“探测localhost的TCP端口,共耗时” +
65             ( end - begin)+"毫秒");
66 }  }

TCP Socket多线程通信

服务端:

 1 import java.io.*;
 2 import java.net.*;
 3 import java.util.*;
 4 @SuppressWarnings(value={"deprecation","unchecked"}) //查阅该语句作用
 5 public class MultiServer extends Thread{
 6     ServerSocket serverSocket = null;
 7     boolean listening = true;
 8     int port = 1080;
 9     int count;
10     public MultiServer(){
11         try{
12             serverSocket = new ServerSocket(port);
13             System.out.println("The Chat Server is listening on " + port);
14         }catch(IOException e){
15             System.err.println("Can‘t listen on Port");
16             System.exit(1);
17         }
18         count = 0;
19         while(listening){
20             try{
21                 new ClientServiceThread(serverSocket.accept()).start();
22                 count += 1;
23                 System.out.println("The Chat Server get " + count + " Clients");
24             }catch(IOException e){
25                 System.err.println("Can‘t Accept the Client Connection Apply");
26             }
27         }
28         try{
29             serverSocket.close();
30         }catch(IOException e){
31             System.exit(1);
32         }
33         this.start();
34     }
35     public static void main(String args[]){
36         MultiServer ms = new MultiServer();
37 } }

客户端:

 1 class ClientServiceThread extends Thread{
 2     private String name = "Client";
 3     private Socket socket = null;
 4     private Vector clients = null;
 5     public ClientServiceThread(Socket socket){
 6         super("ClientServiceThread");
 7         this.socket = socket;
 8     }
 9     public ClientServiceThread(Vector clients, Socket socket){
10         super("ClientServiceThread");
11         this.socket = socket;
12         this.clients = clients;
13     }
14     public void run(){
15         try{
16             DataInputStream in = new DataInputStream(new
17           BufferedInputStream(socket.getInputStream()));
18             PrintStream out = new PrintStream(new
19             BufferedOutputStream(socket.getOutputStream(), 1024), true);
20
21             String inputLine, outputLine;
22
23             GreetingProtocol greeting = new GreetingProtocol();
24             outputLine = greeting.processInput(null);
25
26             out.println("Welcome to My Chat Server,    Please REG your Name, Format: name = yourname");
27             out.flush();
28
29             while((inputLine = in.readLine()) != null){
30                 System.out.println(this.name + " Say: " + inputLine);
31                 if(inputLine.startsWith("name")){
32                     this.name =
33 inputLine.substring(inputLine.indexOf("=") + 1);
34                     out.println("Your Name "+ this.name + " is REG");
35                     out.flush();
36                 }else{
37                     outputLine = greeting.processInput(inputLine);
38                     out.println(outputLine);
39                     out.flush();
40                 }
41                 if(inputLine.equals("bye")) break;
42             }
43             out.close();
44             in.close();
45             socket.close();
46         }catch(IOException e){
47             e.printStackTrace();
48 } } }

原文地址:https://www.cnblogs.com/ftl1012/p/9347677.html

时间: 2024-10-18 02:59:54

Java学习---多线程的学习的相关文章

Java中多线程的学习和使用(一)概述及创建方式

转载请注明http://www.cnblogs.com/devtrees/p/4395477.html 多线程的学习 一.多线程概述 (一).进程与线程 在说多线程或者线程之前,让我们来了解一下更显而易见的进程概念.那什么是进程呢? 进程就是正在进行中的程序. Windows操作系统中在任务栏处右击,弹出的菜单中可看见任务管理器,打开它,就可以看见当前运行的程序和进程列表. 进程:是一个正在执行中的程序. 每一个进程执行都有一个执行顺序.该顺序是一个执行路径,或者叫一个控制单元. 线程:就是进程

【Java】多线程_学习笔记

多线程 1.进程 进程:当一个程序进入内存运行时,它就成为了进程.进程具有独立性.动态性.并发性. A.独立性:进程是系统中独立存在的实体,它可以拥有自己独立的资源,每一个进程都拥有自己私有的地址空间.在没有进程本身允许的情况下,一个用户进程不可以直接访问其他进程的地址空间. B.动态性:进程与程序的区别在于,程序是一个静态的指令集合,而进程是一个正在运行的指令集合.进程有时间的概念,有自己的生命周期和各种不同的状态,而程序不具备这种概念. C.并发性:多个进程可以在单个处理器上并发执行,相互之

Java核心知识点学习----多线程中的阻塞队列,ArrayBlockingQueue介绍

1.什么是阻塞队列? 所谓队列,遵循的是先进先出原则(FIFO),阻塞队列,即是数据共享时,A在写数据时,B想读同一数据,那么就将发生阻塞了. 看一下线程的四种状态,首先是新创建一个线程,然后,通过start方法启动线程--->线程变为可运行可执行状态,然后通过数据产生共享,线程产生互斥---->线程状态变为阻塞状态---->阻塞状态想打开的话可以调用notify方法. 这里Java5中提供了封装好的类,可以直接调用然后构造阻塞状态,以保证数据的原子性. 2.如何实现? 主要是实现Blo

Java核心知识点学习----多线程 倒计时记数器CountDownLatch和数据交换的Exchanger

本文将要介绍的内容都是Java5中的新特性,一个是倒计时记数器---CountDownLatch,另一个是用于线程间数据交换的Exchanger. 一.CountDownLatch 1.什么是CountDownLatch? 倒计时计数器,调用CountDownLatch对象的CountDown()方法就将计数器减一,当计数到达0时,则所有等待者或者全部等待者开始执行. 2.如何用? new CountDownLatch(1); 直接new,其构造函数必须传一个int类型的参数,参数的意思是: c

Java多线程技术学习笔记(二)

目录: 线程间的通信示例 等待唤醒机制 等待唤醒机制的优化 线程间通信经典问题:多生产者多消费者问题 多生产多消费问题的解决 JDK1.5之后的新加锁方式 多生产多消费问题的新解决办法 sleep和wait的区别 停止线程的方式 守护线程 线程的其他知识点 一.线程间的通信示例 返目录回 多个线程在处理同一资源,任务却不同. 假设有一堆货物,有一辆车把这批货物往仓库里面运,另外一辆车把前一辆车运进仓库的货物往外面运.这里货物就是同一资源,但是两辆车的任务却不同,一个是往里运,一个是往外运. 下面

Java多线程编程(学习笔记)

一.说明 周末抽空重新学习了下多线程,为了方便以后查阅,写下学习笔记. 有效利用多线程的关键是理解程序是并发执行而不是串行执行的.例如:程序中有两个子系统需要并发执行,这时候需要利用多线程编程. 通过多线程的使用,可以编写出非常高效的程序.但如果创建了太多的线程,程序执行的效率反而会降低. 同时上下文的切换开销也很重要,如果创建太多的线程,CPU花费在上下文的切换时间将对于执行程序的时间. 二.Java多线程编程 概念 在学习多线程时,我们应该首先明白另外一个概念. 进程:是计算机中的程序关于某

java多线程入门学习(一)

java多线程入门学习(一) 一.java多线程之前 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程.     线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小.     线程和进程一样分为五个阶段:创建.就绪.运行.阻塞.终止.     多进程是指操作系统能同时运行多个任务(程序).     多线程是指在同一程序中有多个顺序流在执行. 在java中要想实现多线程,有两种手段,一种是继承T

Java基础学习之-多线程学习知识点的学习

Java语言从设计之初就把多线程作为语言的核心, 至少从以下几点可以看出: 1. Object对象的wait和notify机制. 2. Thread类在lang包中. 3. synchronized volatile关键字. 虽然多线程是Java语言本身的特性,但是线程并不是Java语言独有的东西,而是操作系统的特性.Java在语言层面进行了封装,使其使用更简单. 多线程存在的价值在哪里呢? 内存读写,磁盘IO, 网络传输的速率远远低于CPU处理数据的速度.所以在大部分场景下,CPU是闲置的.有

多线程--毕向东java基础教程视频学习笔记

多线程运行的安全问题 例子:售票系统 1 class Ticket implements Runnable 2 { 3 //定义静态变量ticket 4 private static int ticket=100; 5 public void run() 6 { 7 while(true) 8 { 9 //判断票编号是否大于0 10 if(ticket>0) 11 { 12 try 13 { 14 Thread.sleep(10); 15 } 16 catch (InterruptedExcep