Java线程：什么是线程

一 基本概念

　　多任务：同一时刻运行多个程序的能力。每一个任务称为一个线程。可以同时运行一个以上线程的程序称为多线程程序。

　　进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

　　线程是指进程中的一个执行流程，一个进程可以运行多个线程。比如java.exe进程可以运行很多线程。线程总是输入某个进程，进程中的多个线程共享进程的内存。

　　Java中线程是指java.lang.Thread类的一个实例或线程的执行。使用java.lang.Thread或java.lang.Runnable接口编写代码定义、实例化、启动新线程。

　　Java中每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行。main()方法运行在一个线程内，称为主线程。一旦创建一个新的线程，就产生一个新的调用栈。

　　线程分为两类：用户线程和守候线程。当所有用户线程执行完毕后，JVM自动关闭。但是守候线程却不独立与JVM，守候线程一般是有操作系统或用户自己创建的。

二 定义线程

1 扩展java.lang.Thread类以及实现java.lang.Runnable接口。

　　此类中有run()方法，public void run()，如果该线程是独立的Runnable运行对象构造的，则调用该Runnable对象的run()方法；否则，该方法不执行任何操作。Thread的子类也应该重写该方法。

三 实例化线程

1 如果是扩展了java.lang.Thread类的线程，则直接调用new即可。

2 如果是实现了jav.lang.Runnable接口的类，则调用Thread的构造方法：

　　Thread(Runnable target)

　　Thread(Runnable target,String name)

　　Thread(ThreadGroup group, Runnable target)

　　Thread(ThreadGroup group, Runnable target, String name)

　　Thread(ThreadGroup group, Runnable target, String name, long stackSize)

四 启动线程

　　在线程的Thread对象上调用start()方法，而不是run()或别的方法。

　　在调用start()方法之前，线程处于新状态中，新状态有一个Thread对象，但没有一个真正的线程。

　　在调用start()方法之后，发生了一系列复杂的事情：　　

　　　　启动新的执行线程(具有新的调用栈)；

　　　　该线程从新状态转移到可运行状态；

　　　　当该线程获得执行机会时，其目标run()方法将运行。

五 注意事项

　　1 获取当前线程的对象的方法是：Thread.currentThread()；

　　2 当线程目标run()方法结束时该线程完成。

　　3 一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。

　　4 线程的调度是JVM的一部分，在一个CPU的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。

　　5 尽管通常采用队列形式，但这是没有保障的。队列形式是指当一个线程完成“一轮”时，它移到可运行队列的尾部等待，直到它最终排队到该队列的前端为止，它才能被再次选中。事实上，我们把它称为可运行池而不是一个可运行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列一个队列的事实。

　　6 尽管我们没有无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式。

六 示例

　　当点击start按钮时，程序从屏幕左上角弹出一个球，这个球开始移动，调用addBall方法，循环运行1000次move。每调用一次move，球就会移动一点，当碰到墙壁时，就会调整方向，但是这个程序有个弊端：当你想在移动1000次之前，就想退出程序，点击close发现，其仍在移动。

　　Thread类的静态方法sleep()将暂停给定的毫秒数。调用Thread.sleep不会创建一个新线程，sleep是Thread类的静态方法，用于暂停当前线程活动。

　　Bounce.java

 1 package Thread;
 2 import java.awt.*;
 3 import java.awt.event.*;
 4 import javax.swing.*;
 5 public class BounceThread {
 6     public static void main(String[] args){
 7         EventQueue.invokeLater(new Runnable(){
 8             public void run(){
 9                 JFrame frame=new BounceFrame();
10                 frame.setTitle("BounceFrame");
11                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12                 frame.setVisible(true);
13             }
14         });
15     }
16 }
17 /*class BallRunnable implements Runnable{
18     private Ball ball;
19     private Component component;
20     public static final int STEPS=1000;
21     public static final int DELAY=5;
22     public BallRunnable(Ball aBall,Component aComponent){
23         ball=aBall;
24         component=aComponent;
25     }
26     public void run(){
27         try{
28             for(int i=1;i<=STEPS;i++){
29                 ball.move(component.getBounds());
30                 component.repaint();
31                 Thread.sleep(DELAY);
32             }
33         }
34         catch(InterruptedException e){}
35     }
36 }*/
37 class BounceFrame extends JFrame{
38     private BallComponent comp;
39     public static final int STEPS=1000;
40     public static final int DELAY=100;
41     public BounceFrame(){
42         comp=new BallComponent();
43         add(comp,BorderLayout.CENTER);
44         JPanel buttonPanel=new JPanel();
45         addButton(buttonPanel,"Start",new ActionListener(){
46             public void actionPerformed(ActionEvent event){
47                 addBall();
48             }
49         });
50         addButton(buttonPanel,"Close",new ActionListener(){
51             public void actionPerformed(ActionEvent event){
52                 System.exit(0);
53             }
54         });
55         add(buttonPanel,BorderLayout.SOUTH);
56         pack();
57     }
58     public void addButton(Container c,String title,ActionListener listener){
59         JButton button=new JButton(title);
60         c.add(button);
61         button.addActionListener(listener);
62     }
63     /*public void addBall(){
64         Ball b=new Ball();
65         comp.add(b);
66         Runnable r=new BallRunnable(b,comp);
67         Thread t=new Thread(r);
68         t.start();
69     }*/
70     public void addBall(){
71         try{
72             Ball ball=new Ball();
73             comp.add(ball);
74             for(int i=1;i<=STEPS;i++){
75                 ball.move(comp.getBounds());
76                 comp.paint(comp.getGraphics());
77                 Thread.sleep(DELAY);
78             }
79         }
80         catch(InterruptedException e){}
81     }
82 }

　　BollComponent.java

 1 package Thread;
 2 import java.awt.*;
 3
 4 import java.util.*;
 5 import javax.swing.*;
 6 public class BallComponent extends JPanel{
 7     private static final int DEFAULT_WIDTH=450;
 8     private static final int DEFAULT_HEIGHT=350;
 9     private java.util.List<Ball>balls=new ArrayList<>();
10     public void add(Ball b){
11         balls.add(b);
12     }
13     public void paintComponent(Graphics g){
14         super.paintComponent(g);
15         Graphics2D g2=(Graphics2D)g;
16         for(Ball b:balls){
17             g2.fill(b.getShape());
18         }
19     }
20     public Dimension getPreferredSize(){
21         return new Dimension(DEFAULT_WIDTH,DEFAULT_HEIGHT);
22     }
23 }

　　Ball.java

 1 package Thread;
 2 import java.awt.geom.*;
 3 import java.awt.geom.Ellipse2D.Double;
 4 public class Ball {
 5     private static final int XSIZE=15;
 6     private static final int YSIZE=15;
 7     private double x=0;
 8     private double y=0;
 9     private double dx=1;
10     private double dy=1;
11     public void move(Rectangle2D bounds){
12         x+=dx;
13         y+=dy;
14         if(x<bounds.getMinX()){
15             x=bounds.getMinX();
16             dx=-dx;
17         }
18         if(x+XSIZE>=bounds.getMaxX()){
19             x=bounds.getMaxX()-XSIZE;
20             dx=-dx;
21         }
22         if(y<bounds.getMinY()){
23             y=bounds.getMinY();
24             dy=-dy;
25         }
26         if(y+YSIZE>=bounds.getMaxY()){
27             y=bounds.getMaxY()-YSIZE;
28             dy=-dy;
29         }
30     }
31     public Ellipse2D getShape(){
32         return new Ellipse2D.Double(x,y,XSIZE,YSIZE);
33     }
34 }

针对上述的情况，下面的代码是改进后的，当点击close时，就会退出当前线程。

　BounceThread.java

 1 package Thread;
 2 import java.awt.*;
 3 import java.awt.event.*;
 4 import javax.swing.*;
 5 public class BounceThread {
 6     public static void main(String[] args){
 7         EventQueue.invokeLater(new Runnable(){
 8             public void run(){
 9                 JFrame frame=new BounceFrame();
10                 frame.setTitle("BounceFrame");
11                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12                 frame.setVisible(true);
13             }
14         });
15     }
16 }
17 class BallRunnable implements Runnable{
18     private Ball ball;
19     private Component component;
20     public static final int STEPS=1000;
21     public static final int DELAY=5;
22     public BallRunnable(Ball aBall,Component aComponent){
23         ball=aBall;
24         component=aComponent;
25     }
26     public void run(){
27         try{
28             for(int i=1;i<=STEPS;i++){
29                 ball.move(component.getBounds());
30                 component.repaint();
31                 Thread.sleep(DELAY);
32             }
33         }
34         catch(InterruptedException e){}
35     }
36 }
37 class BounceFrame extends JFrame{
38     private BallComponent comp;
39     //public static final int STEPS=1000;
40     //public static final int DELAY=100;
41     public BounceFrame(){
42         comp=new BallComponent();
43         add(comp,BorderLayout.CENTER);
44         JPanel buttonPanel=new JPanel();
45         addButton(buttonPanel,"Start",new ActionListener(){
46             public void actionPerformed(ActionEvent event){
47                 addBall();
48             }
49         });
50         addButton(buttonPanel,"Close",new ActionListener(){
51             public void actionPerformed(ActionEvent event){
52                 System.exit(0);
53             }
54         });
55         add(buttonPanel,BorderLayout.SOUTH);
56         pack();
57     }
58     public void addButton(Container c,String title,ActionListener listener){
59         JButton button=new JButton(title);
60         c.add(button);
61         button.addActionListener(listener);
62     }
63     public void addBall(){
64         Ball b=new Ball();
65         comp.add(b);
66         Runnable r=new BallRunnable(b,comp);
67         Thread t=new Thread(r);
68         t.start();
69     }
70     /*public void addBall(){
71         try{
72             Ball ball=new Ball();
73             comp.add(ball);
74             for(int i=1;i<=STEPS;i++){
75                 ball.move(comp.getBounds());
76                 comp.paint(comp.getGraphics());
77                 Thread.sleep(DELAY);
78             }
79         }
80         catch(InterruptedException e){}
81     }*/
82 }

　BollComponent.java

 1 package Thread;
 2 import java.awt.*;
 3
 4 import java.util.*;
 5 import javax.swing.*;
 6 public class BallComponent extends JPanel{
 7     private static final int DEFAULT_WIDTH=450;
 8     private static final int DEFAULT_HEIGHT=350;
 9     private java.util.List<Ball>balls=new ArrayList<>();
10     public void add(Ball b){
11         balls.add(b);
12     }
13     public void paintComponent(Graphics g){
14         super.paintComponent(g);
15         Graphics2D g2=(Graphics2D)g;
16         for(Ball b:balls){
17             g2.fill(b.getShape());
18         }
19     }
20     public Dimension getPreferredSize(){
21         return new Dimension(DEFAULT_WIDTH,DEFAULT_HEIGHT);
22     }
23 }

　　Ball.java

 1 package Thread;
 2 import java.awt.geom.*;
 3 import java.awt.geom.Ellipse2D.Double;
 4 public class Ball {
 5     private static final int XSIZE=15;
 6     private static final int YSIZE=15;
 7     private double x=0;
 8     private double y=0;
 9     private double dx=1;
10     private double dy=1;
11     public void move(Rectangle2D bounds){
12         x+=dx;
13         y+=dy;
14         if(x<bounds.getMinX()){
15             x=bounds.getMinX();
16             dx=-dx;
17         }
18         if(x+XSIZE>=bounds.getMaxX()){
19             x=bounds.getMaxX()-XSIZE;
20             dx=-dx;
21         }
22         if(y<bounds.getMinY()){
23             y=bounds.getMinY();
24             dy=-dy;
25         }
26         if(y+YSIZE>=bounds.getMaxY()){
27             y=bounds.getMaxY()-YSIZE;
28             dy=-dy;
29         }
30     }
31     public Ellipse2D getShape(){
32         return new Ellipse2D.Double(x,y,XSIZE,YSIZE);
33     }
34 }

运行结果如下：

时间： 2024-08-28 02:54:59

Java线程：什么是线程的相关文章

java 使用volatile实现线程数据的共享

直接上代码看效果: public class VolatileTest extends Thread { private volatile boolean isRunning = true; private void setRunning(boolean s) { isRunning = s; } @Override public void run() { System.out.println(isRunning); while (isRunning) { //System.out.printl

Java多线程（二） —— 线程安全、线程同步、线程间通信（含面试题集）

一.线程安全 多个线程在执行同一段代码的时候,每次的执行结果和单线程执行的结果都是一样的,不存在执行结果的二义性,就可以称作是线程安全的. 讲到线程安全问题,其实是指多线程环境下对共享资源的访问可能会引起此共享资源的不一致性.因此,为避免线程安全问题,应该避免多线程环境下对此共享资源的并发访问. 线程安全问题多是由全局变量和静态变量引起的,当多个线程对共享数据只执行读操作,不执行写操作时,一般是线程安全的:当多个线程都执行写操作时,需要考虑线程同步来解决线程安全问题. 二.线程同步(synchr

Java用户线程和守护线程

1.用户线程和守护线程的区别用户线程和守护线程都是线程,区别是Java虚拟机在所有用户线程dead后,程序就会结束.而不管是否还有守护线程还在运行,若守护线程还在运行,则会马上结束.很好理解,守护线程是用来辅助用户线程的,如公司的保安和员工,各司其职,当员工都离开后,保安自然下班了. 2.用户线程和守护线程的适用场景由两者的区别及dead时间点可知,守护线程不适合用于输入输出或计算等操作,因为用户线程执行完毕,程序就dead了,适用于辅助用户线程的场景,如JVM的垃圾回收,内存管理都是守护线程,

java内存模型与线程(转) good

java内存模型与线程 参考 http://baike.baidu.com/view/8657411.htm http://developer.51cto.com/art/201309/410971_all.htm http://www.cnblogs.com/skywang12345/p/3447546.html 计算机的CPU计算能力超强,其计算速度与 内存等存储 和通讯子系统的速度相比快了几个数量级, 数据加载到内存中后,cpu处理器运算处理时,大部分时间花在等待获取去获取磁盘IO.网络通

Java多线程-新特性-线程池

Sun在Java5中,对Java线程的类库做了大量的扩展,其中线程池就是Java5的新特征之一,除了线程池之外,还有很多多线程相关的内容,为多线程的编程带来了极大便利.为了编写高效稳定可靠的多线程程序,线程部分的新增内容显得尤为重要. 有关Java5线程新特征的内容全部在java.util.concurrent下面,里面包含数目众多的接口和类,熟悉这部分API特征是一项艰难的学习过程.目前有关这方面的资料和书籍都少之又少,大部分介绍线程方面书籍还停留在java5之前的知识层面上. 在Java5之

java学习笔记15--多线程编程基础2

本文地址:http://www.cnblogs.com/archimedes/p/java-study-note15.html,转载请注明源地址. 线程的生命周期 1.线程的生命周期 线程从产生到消亡的过程 一个线程在任何时刻都处于某种线程状态(thread state) 线程生命周期状态图 诞生状态 线程刚刚被创建 就绪状态 线程的 start 方法已被执行 线程已准备好运行 运行状态 处理机分配给了线程,线程正在运行 阻塞状态(Blocked) 在线程发出输入/输出请求且必须等待其返回 遇到

JAVA 并发编程之线程管理2

今天,我们注重分析下Thread类.这个类有一些信息的属性.这些属性可以用来标识线程,显示线程的状态或者控制线程的优先级. ID:保存了线程的唯一标识. Name:保存了线程的名称 Priority:保存了线程的优先级. Status:保存了线程的状态.java中线程的状态有:new,runnable,blocked,waiting,time waiting或者terminated. 现在,编写一个程序为10个线程指定名称和优先级,并且输出他们的状态信息直到线程结束.每个线程都将计算一个数字的乘

Java 并发编程之线程池的使用

在任务与执行策略之间的隐性耦合 Executor框架可以将任务的提交与任务的执行策略解耦开来(就是独立化).虽然Executor框架为制定和修改执行策略都提供了相当大的灵活性,但并非所有的任务都能适用所有的执行策略 比如: 依赖性任务 比如依赖于执行时序,执行结果或者其他效果,那么任务就带有隐含的依赖性.此时必须小心 地维持这些执行策略以避免产生活跃性问题(死锁等造成执行困难的问题) 使用线程封闭机制的任务 与线程池相比,单线程的Executor能够对并发性做出更强的承诺,它们能确保任务不会并发

Java并发学习之五——线程的睡眠和恢复

本文是学习网络上的文章时的总结,感谢大家无私的分享. 1.Thread类的sleep方法,可以使线程睡眠.此方法接收一个整数作为参数,表示线程暂停运行的毫秒数.在调用sleep方法后,当时间结束时,JVM会安排他们CPU时间,线程会继续按指令执行. 另一种可能是使用一个有TimeUnit列举元素的sleep方法,使用线程类的sleep方法让当前线程睡眠,但是它接收的参数单位后会转成毫秒的. 2.当你调用sleep()方法,Thread离开CPU并在一段时间内停止运行.在这段时间内,他是不消耗CP

Java内存模型与线程

写在前面:与之前主流程序语言(c/c++等)直接使用物理硬件和操作系统的内存模型不同,java虚拟机为了屏蔽各种硬件和操作系统的内存访问差异定义了一种java内存模型.其主要定义程序中各个变量的访问规则(在虚拟机中将变量存储到内存和从内存中取出变量的底层细节). 线程.主内存.工作内存之间的交互关系 1.java内存模型结构: -所有的变量都存储在主内存中. -每条线程还有自己的工作内存. -工作内存中保存了从主内存中拷贝的该线程所要使用到的变量 -每条线程对变量的操作必须在自己的工作内存中,不