Java入门——多线程(一)

Java入门——多线程(一)


进程与线程的区别

  进程是程序的一次动态的执行的过程,需要经历从代码的加载,代码执行到执行完毕的一个完整过程,这个过程也是进程重产生,发展到最终消亡的过程。多进程操作系统利用CPU的分时机制,分时段执行不同程序,由于CPU运行速度非常快,所以就想是多个进程同时运行一样。

  线程是比进程更小的执行单位,线程在进程的基础之上进行的进一步划分。所谓多线程是指在一个进程在执行过程中可以产生多个更小的程序单元,这些更小的单元成为线程,可以同时存在,同时运行。

  所谓的线程是程序的运行流程,多线程就是指可以同时运行多个程序块(Java语言支持多线程)。


线程的实现

  主要有两种手段,第一是继承Thread类,第二个是实现Runable接口。

继承Thread类

  Thread类是java.lang包中定义的,一个类只要继承了Thread类,此类就称为多线程实现类。在Thread子类中,必须覆写run()方法,此方法为线程的主体,线程类的定义如下:

 1 package Sep18;
 2 /*
 3  * 线程类的格式
 4  * class 类名称 extends Thread{
 5  *         属性------;
 6  *         方法------;
 7  *         public void run(){
 8  *             线程主体;
 9  *     }
10  * }
11  */
12 public class ThreadDemo01 {
13     public static void main(String args[]){
14         MyThread mt1=new MyThread("线程A");
15         MyThread mt2=new MyThread("线程B");
16
17         mt1.start();//启动多线程
18         mt2.start();//启动多线程
19
20     }
21 }
22 class MyThread extends Thread{
23     private String name;
24     public MyThread(String name){
25         this.name=name;
26     }
27     public void run(){
28         for (int i=0;i<10;i++){
29             System.out.println(name+"运行,i="+i);
30         }
31     }
32 }
线程A运行,i=0
线程A运行,i=1
线程A运行,i=2
线程A运行,i=3
线程A运行,i=4
线程B运行,i=0
线程B运行,i=1
线程A运行,i=5
线程A运行,i=6
线程A运行,i=7
线程A运行,i=8
线程B运行,i=2
线程A运行,i=9
线程B运行,i=3
线程B运行,i=4
线程B运行,i=5
线程B运行,i=6
线程B运行,i=7
线程B运行,i=8
线程B运行,i=9

  如果一个类通过继承Thread方法实现多线程,那么只能调用一次start()方法,否者会出现异常。

实现Runnable接口

  Runnable接口只定义了一个抽象方法:public void run();

/*
 3  * 线程类的格式
 4  * class 类名称 implements Thread{
 5  *         属性------;
 6  *         方法------;
 7  *         public void run(){
 8  *             线程主体;
 9  *     }
10  * }
11  */
 1 package Sep18;
12 public class ThreadDemo02 {
13     public static void main(String args[]){
14         MyThread2 mt1=new MyThread2("线程A");
15         MyThread2 mt2=new MyThread2("线程B");
16         Thread t1=new Thread(mt1);
17         Thread t2=new Thread(mt2);
18         t1.start();//启动多线程
19         t2.start();//启动多线程
20
21     }
22 }
23 class MyThread2 implements Runnable{
24     private String name;
25     public MyThread2(String name){
26         this.name=name;
27     }
28     public void run(){
29         for (int i=0;i<10;i++){
30             System.out.println(name+"运行,i="+i);
31         }
32     }
33 }
线程A运行,i=0
线程A运行,i=1
线程B运行,i=0
线程A运行,i=2
线程B运行,i=1
线程A运行,i=3
线程B运行,i=2
线程A运行,i=4
线程B运行,i=3
线程A运行,i=5
线程B运行,i=4
线程A运行,i=6
线程B运行,i=5
线程A运行,i=7
线程B运行,i=6
线程A运行,i=8
线程B运行,i=7
线程A运行,i=9
线程B运行,i=8
线程B运行,i=9

  实际上实现Runnable接口后,开始线程还是利用的Thread的两个构造方法: public Thread(Runnable target);和public Thread (Runnable target , String name);这两个构造函数都接受Runnable接口的子类实例对象。


用Runnable接口实现多线程的优势

  首先第一点:避免Java单继承带来的限制。

  然后:增强程序的健壮性,代码能够被对个线程共享,代码与数据是独立的。适合多个相同程序代码处理同一资源的情况。

  看下面例子理解第二点:

  使用继承Thread类:

 1 package Sep18;
 2
 3 public class ThreadDemo03 {
 4     public static void main(String args[]){
 5     MyThread02 mt01=new MyThread02();
 6     MyThread02 mt02=new MyThread02();
 7     MyThread02 mt03=new MyThread02();
 8     mt01.start();
 9     mt02.start();
10     mt03.start();
11     }
12 }
13 class MyThread02 extends Thread{
14     private int ticket=5;
15     public void run(){
16         for (int i=0;i<=12;i++){
17             if (ticket>0){
18                 System.out.println("卖一张票,剩余:"+ticket+"张");
19                 ticket--;
20             }
21         }
22     }
23 }
卖一张票,剩余:5张
卖一张票,剩余:4张
卖一张票,剩余:5张
卖一张票,剩余:5张
卖一张票,剩余:4张
卖一张票,剩余:3张
卖一张票,剩余:2张
卖一张票,剩余:1张
卖一张票,剩余:3张
卖一张票,剩余:2张
卖一张票,剩余:4张
卖一张票,剩余:1张
卖一张票,剩余:3张
卖一张票,剩余:2张
卖一张票,剩余:1张

使用Runnable接口实现数据共享的多线程。(核心在于这样的子类可以使用多次start())

 1 package Sep18;
 2
 3 public class ThreadDemo04 {
 4     public static void main(String args[]){
 5     MyThread03 mt01=new MyThread03();
 6     new Thread(mt01).start();
 7     new Thread(mt01).start();
 8     new Thread(mt01).start();
 9
10     }
11 }
12 class MyThread03 implements Runnable{
13     private int ticket=10;
14     public void run(){
15         for (int i=0;i<=12;i++){
16             if (ticket>0){
17                 System.out.println("卖一张票,剩余:"+ticket--);
18             }
19         }
20     }
21 }
时间: 2024-10-11 03:48:44

Java入门——多线程(一)的相关文章

Java入门——多线程(二)

Java入门——多线程(二) 线程的状态 要想实现多线程,必须在主线程中创建新的线程对象.任何线程一般具有5种状态. 创建状态:用构造方法创建一个线程对象之后,新的线程就处于该状态.已经有了相应的内存空间和其他资源和其他资源. 就绪状态:线程进入线程队列排队,等待CPU服务. 运行状态:CPU处理,自动调用run()方法. 阻塞状态:就是在执行过程中暂时挂起.原因有:人为挂起,CPU的决定,sleep(),suspend(),wait()等方法.只有当引起阻塞的原因被消除后,线程才能转入就绪状态

Java的多线程 简单入门

Java的多线程 简单入门 首先可以先搞清楚什么是程序.进程.线程,以及它们之间的关系: 定义: 一 程序只是一组指令的有序集合,它是静态的 二 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,是系统进行资源分配和调度的一个独立单位: 三 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),一个线程可以创建和撤销另一个线程: 进程与线程区别与联系 (

Java入门 - 高级教程 - 07.多线程

原文地址:http://www.work100.net/training/java-multi-threading.html更多教程:光束云 - 免费课程 多线程 序号 文内章节 视频 1 概述 - 2 一个线程的生命周期 - 3 线程的优先级 - 4 创建一个线程 - 5 通过实现Runnable接口来创建线程 - 6 通过继承Thread来创建线程 - 7 通过继承Thread来创建线程 - 8 通过Callable和Future创建线程 - 9 创建线程的三种方式的对比 - 10 线程的几

Java - Java入门(2-1am)

第一讲.Java入门 1. 计算机语言是人和计算机进行交互的一种工具,人们通过使用计算机语言编写程序来向计算机施令,计算机则执行程序,并把结果输出给用户. 2. 机器语言:由0.1序列构成的指令码组成 如:10000000  加        10010000减          11110000 打印 3. 汇编语言:用助记符号描述的指令系统 如: Mov   A, #10; Mov   B, #20; Add   A,  B; 4. 高级语言: 面向过程的高级语言:程序设计的基本单元为函数

Java入门——面向对象基础(三)

Java入门——抽象类与接口的应用 本Blog内容 为抽象类与接口实例化 抽象类的实际应用——模板设计 接口的实际应用——制定标准 设计模式——工厂设计 设计模式——代理设计 为抽象类与接口实例化 利用多态性 1 package Sep16; 2 3 public class AbstractCaseDemo1 { 4 5 /** 6 * @param args 7 */ 8 public static void main(String[] args) { 9 // TODO Auto-gene

Java基础--多线程的方方面面

1,什么是线程?线程和进程的区别是什么? 2,什么是多线程?为什么设计多线程? 3,Java种多线程的实现方式是什么?有什么区别? 4,线程的状态控制有哪些方法? 5,线程安全.死锁和生产者--消费者 6,线程的优化有哪些方法? 1,什么是线程?线程和进程的区别是什么? 线程是程序执行的最小单元. 区别: 进程是操作系统进行资源处理和分配的最小单位,而一个进程可以包含多个线程,并共享进程的资源. 2,什么是多线程?为什么设计多线程? 介绍之前,我们需要理解并行和并发的定义: 并行:同一个时刻有多

Java的多线程编程模型5--从AtomicInteger开始

Java的多线程编程模型5--从AtomicInteger开始 2011-06-23 20:50 11393人阅读 评论(9) 收藏 举报 java多线程编程jniinteger测试 AtomicInteger,一个提供原子操作的Integer的类.在Java语言中,++i和i++操作并不是线程安全的,在使用的时候,不可避免的会用到synchronized关键字.而AtomicInteger则通过一种线程安全的加减操作接口. 来看AtomicInteger提供的接口. //获取当前的值 publ

java实现多线程下载

本篇博客可认为是对 使用java实现http多线程下载 一文的再次解读. 首先,从宏观来说 java实现多线程下载这个功能的实现由以下几部分组成: 1 建立多个线程去分别下载文件的一部分. 2 将多个线程下载的文件(还在内存中),写入硬盘中的一个文件. 3 断点续传 GET /Path/FileName HTTP/1.0 Host: www.server.com:80 Accept: */* User-Agent: GeneralDownloadApplication Connection: c

java入门第二步之helloworld【转】

前一篇博客已经介绍了jdk的安装:接下来我们就乘热打铁,完成第一个程序:helloworld(每学一样程序的新东西都是从实现helloworld开始的) 1.不是用开发工具IDE,只是使用记事本来实现: 打开计算本,在记事本上写如下代码,现在可以先不管是什么意思: public class HelloWorld { public static void main(String[] args) { System.out.println("这是我的第一个程序!!"); } } 保存,文件名