进程:是一个正在执行中的程序。
每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。线程在控制着进程的执行。
一个进程中至少有一个线程。
比如说:JavaVM 启动的时候会有一个进程java.exe.
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回收机制的线程。
自定义一个线程
通过对api的查找,java已经提供了对线程这类事物的描述。就Thread类。
该类中定义了,创建线程对象的方法(构造函数).提供了要被线程执行的代码存储的位置(run())
还定义了开启线程运行的方法(start()).
同时还有一些其他的方法用于操作线程:
staticThread currentThead():
StringgetName():
staticvoid sleep(time)throws InterruptedException:
创建线程的第一种方式:继承Thread类。
步骤:
1,定义类继承Thread。
2,复写Thread类中的run方法。
目的:将自定义代码存储在run方法。让线程运行。
3,调用线程的start方法,
该方法两个作用:启动线程,调用run方法。
class PrimeRun implements Runnable
{
long minPrime;
PrimeRun(long minPrime)
{
this.minPrime = minPrime;
}
public void run()
{// compute primes larger than minPrime . . . } }
然后,下列代码会创建并启动一个线程:
PrimeRun p = new PrimeRun(143);
new Thread(p).start();
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权。cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序在运行。(多核除外)
cpu在做着快速的切换,以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说的算。
线程的状态。
1,被创建。
2,运行。
3,冻结。
4,消亡。
其实还有一种特殊的状态:临时状态。该临时状态的特点:具备了执行资格,但不具备执行权。
冻结状态的特点:放弃了执行资格。
多线程具备随机性。因为是由cpu不断的快速切换造成的。就有可能会产生多线程的安全问题。
问题的产生的原因:
1,多线程代码中有操作共享数据。
2,多条语句操作该共享数据。
当具备两个关键点时,
有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完,另一个线程开始参与执行。就会发生数据错误。
解决方法:
当一个线程在执行多条操作共享数据代码时,其他线程即使获取了执行权,也不可以参与操作。
Java就对这种解决方式提供了专业的代码。
同步:
同步的原理:就是将部分操作功能数据的代码进行加锁。
同步的表现形式:
1,同步代码块。
2,同步函数。
两者不同:
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。
注意:对于static的同步函数,使用的锁不是this。是 类名.class 是该类的字节码文件 对象。涉及到了单例设计模式的懒汉式。
单例设计模式。
//饿汉式。
class Single
{
privatestatic final Single s = new Single();
privateSingle(){}
publicstatic Single getInstance()
{
returns;
}
}
//懒汉式
class Single
{
privatestatic Single s = null;
privateSingle(){}
publicstatic Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s= new Single();
}
}
returns;
}
}
class SingleDemo
{
publicstatic void main(String[] args)
{
System.out.println("HelloWorld!");
}
}
如果同步函数被静态修饰后,使用的锁
通过验证,发现不在是this。因为静态方法中也不可以定义this。
静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
class Ticket implements Runnable
{
privatestatic int tick = 100;
booleanflag = true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(Ticket.class)
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exceptione){}
System.out.println(Thread.currentThread().getName()+"....code: "+ tick--);
}
}
}
}
else
while(true)
show();
}
publicstatic synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exceptione){}
System.out.println(Thread.currentThread().getName()+"....show....: "+ tick--);
}
}
}
classStaticMethodDemo
{
publicstatic void main(String[] args)
{
Tickett = new Ticket();
Threadt1 = new Thread(t); //线程
Threadt2 = new Thread(t);
t1.start(); //启动线程run方法
try{Thread.sleep(10);}catch(Exceptione){}
t.flag= false;
t2.start();
}
}
//例:电子时钟,通过sleep()方法改变线程的状态。代码
import java.util.Calendar;
import java.util.GregorianCalendar;
import javax.swing.*;
public class DigitalCiock {
public static void main(String[] args) {
// TODO Auto-generated method stub
JFrame jf = new JFrame("Clock");
JLabel clock = new JLabel("Clock");
clock.setHorizontalAlignment(JLabel.CENTER);
jf.add(clock,"Center");
jf.setSize(140,80);
jf.setLocation(500,300);
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jf.setVisible(true);
Thread t = new MyThread(clock);
t.start();
}
}
class MyThread extends Thread{
private JLabel clock;
public MyThread(JLabel clock){
this.clock = clock;
}
public void run(){
while(true){
clock.setText(this.getTime());
try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
public String getTime(){
Calendar c = new GregorianCalendar();
String time = c.get(Calendar.YEAR)+"-"+(c.get(Calendar.MONTH)+1)+"-"+c.get(Calendar.DATE)+" ";
int h = c.get(Calendar.HOUR_OF_DAY);
int m = c.get(Calendar.MINUTE);
int s = c.get(Calendar.SECOND);
String ph = h<10 ?"0":"";
String pm = m<10 ?"0":"";
String ps = s<10 ?"0":"";
time +=ph + h + ":" + pm + m + ":" + ps + s;
return time;
}
}
//例:线程对象的生命周期从创建到结束。代码
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.*;
public class TestStatus extends WindowAdapter implements ActionListener{
Frame f;
static TestStatus.ThreadTest t1,t2;
public static void main(String[] args) {
TestStatus w=new TestStatus();
w.display();
t1=w.new ThreadTest("Welecome to Java world!");
t2=w.new ThreadTest("Welecome to Study thread!");
t2.start();
t2.setButton();
}
public void display(){
f=new Frame("welcome");
f.setSize(200,200);
f.setLocation(200,140);
f.setBackground(Color.lightGray);
f.setLayout(new GridLayout(4,1));
f.addWindowListener(this);
//f.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if((e.getSource()==t1.b1)||(e.getSource()==t1.b2))
actionPerformed(e,t1);
if((e.getSource()==t2.b1)||(e.getSource()==t2.b2))
actionPerformed(e,t2);
}
public void actionPerformed(ActionEvent e,ThreadTest t){
if(e.getSource()==t.b1){
t.sleeptime=Integer.parseInt(t.tf2.getText());
t.start();
}
if(e.getSource()==t.b2)
t.interrupt();
t.setButton();
}
public class ThreadTest extends Thread{
Panel p1;
Label lb1;
TextField tf1,tf2;
Button b1,b2;
int sleeptime=(int)(Math.random()*100);
public ThreadTest(String str){
super(str);
for(int i=0;i<100;i++){
str=str+" ";
}
tf1=new TextField(str);
f.add(tf1);
p1=new Panel();
p1.setLayout(new FlowLayout(FlowLayout.LEFT));
lb1=new Label("sleep");
tf2=new TextField(""+sleeptime);
p1.add(lb1);
p1.add(tf2);
b1=new Button("启动");
b2=new Button("中断");
p1.add(b1);
p1.add(b2);
b1.addActionListener(new TestStatus());
b2.addActionListener(new TestStatus());
f.add(p1);
f.setVisible(true);
}
public void run(){
String str;
//while(this.isAlive() &&!this.isInterrupted()){
while(true){
try{
str=tf1.getText();
str=str.substring(1)+str.substring(0,1);
tf1.setText(str);
Thread.sleep(sleeptime);
}catch(InterruptedException e){
System.out.println(e);
break;
}
}
}
public void setButton(){
if(this.isAlive()) b1.setEnabled(false);
if(this.isInterrupted()) b2.setEnabled(false);
}
}
@Override
public void windowClosing(WindowEvent e) {
// TODO Auto-generated method stub
System.exit(0);
}
}
分享到:
相关推荐
电子书相关:包含4个有关JAVA线程的电子书(几乎涵盖全部有关线程的书籍) OReilly.Java.Threads.3rd.Edition.Sep.2004.eBook-DDU Java Thread Programming (Sams) java线程第二版中英文 java线程第二版中英文 ...
### Java线程详解 在Java开发中,线程(Thread)是执行程序的基本单位,它是一种轻量级的进程,可以实现并发操作,提高程序的运行效率。本篇内容将围绕Java线程的基础知识、创建方式、生命周期以及线程同步等核心...
Java线程状态流转图知识点总结 Java线程状态流转图是一种用于描述Java线程生命周期中不同的状态和状态转换的图形表示方式。该图形展示了Java线程从创建到终止的整个生命周期,并详细介绍了每种状态的特点和转换...
Java线程分析是Java开发中的重要环节,尤其是在处理性能优化、死锁排查或者并发问题时。TDA(Thread Dump Analyzer)是一款强大的Java线程分析工具,它能够帮助开发者深入理解应用在运行时的线程状态,包括线程的...
java 线程Dump 分析工具: Java的TDA线程转储分析器是一个用于分析Sun Java VM生成的线程转储和堆信息的小型Swing GUI(目前用1.4测试)。它从提供的日志文件中解析线程转储和类直方图。它提供关于发现的线程转储的...
根据提供的信息,我们可以推断出这份文档主要关注的是Java线程的相关内容。下面将围绕“Java线程”这一主题展开详细的介绍与解释。 ### Java线程基础 在Java语言中,线程是程序执行流的基本单元。一个标准的Java...
Java线程是并发编程的核心部分,它允许程序在同一时间执行多个独立的任务,从而提高系统效率和响应速度。本文将深入探讨Java线程的概念、生命周期、实现方式以及相关的同步机制。 首先,理解线程的基本概念至关重要...
Java线程是多任务编程的重要概念,它允许程序同时执行多个独立的任务,从而提高系统效率和响应速度。在Java中,线程可以分为用户线程和守护线程,前者是程序运行的基础,而后者是在所有用户线程结束时才终止的后台...
Java线程是Java编程语言中的一个核心概念,它允许程序同时执行多个任务,极大地提高了程序的并发性和效率。本教程将深入探讨Java线程的使用,帮助开发者掌握这一关键技术。 一、线程基础 1. **线程的概念**:线程...
Java线程是Java编程中的重要概念,特别是在多核处理器和并发处理中不可或缺。Java线程允许程序在同一时间执行多个不同的任务,从而提高了程序的效率和响应性。在燕山大学信息学院计算机系的课程中,李峰教授讲解了...
Java线程是Java编程语言中的核心概念,尤其在多任务处理和并发编程中扮演着重要角色。线程允许一个程序内部同时执行多个独立的控制流,使得程序能够更高效地利用处理器资源。本文将深入解析Java线程的相关知识点,...
《Java线程(第三版)》是一本深入探讨Java线程技术的专业书籍,旨在帮助开发者理解和掌握Java平台上的多线程编程。Java线程是并发编程的重要组成部分,它允许程序同时执行多个任务,从而充分利用系统资源,提高程序的...
Java线程是Java编程语言中的一个核心概念,它允许程序同时执行多个任务,极大地提高了程序的效率和响应性。在Java中,线程是通过类`Thread`或实现`Runnable`接口来创建和管理的。Java线程模型是基于操作系统的原生...
Java线程是多任务编程中的核心概念,它允许程序同时执行多个不同的任务,极大地提高了程序的效率和响应性。在Java中,线程是通过Java.lang.Thread类或实现Runnable接口来创建和管理的。这份“java线程文档大全”包含...
JAVA线程dump的分析 JAVA线程dump是指在JAVA程序中,当前线程的状态和调用堆栈的快照,能够帮助开发者了解当前程序的执行情况,诊断问题和性能瓶颈。生成JAVA线程dump的方法在不同的操作系统下是不同的,在Windows...
### Java线程培训资料知识点详解 #### 一、Java线程基本概念 1. **如何编写与启动线程** - **方式一:继承Thread类** ```java class MyThread extends Thread { @Override public void run() { // 业务逻辑 ...
4种常用Java线程锁的特点,性能比较、使用场景 线程(thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发...
本资源"JAVA线程学习(源代码)"提供了关于Java线程的源代码示例,帮助我们深入理解和实践线程的使用。 首先,我们要理解Java中的线程模型。Java线程由`java.lang.Thread`类或`java.util.concurrent.Executor`框架来...
Java 线程状态转换图 Java 线程状态转换图是 Java 编程中非常重要的一个概念,它描述了线程在不同的状态之间的转换关系。了解线程状态转换图对 Java 编程的理解和应用非常重要。本文将详细介绍 Java 线程状态转换图...
本文将深入探讨Java线程的核心概念、API以及在实际开发中的应用,旨在帮助你理解和掌握这一关键技能。 首先,我们需要了解什么是线程。在单核CPU系统中,线程是操作系统调度的基本单位,而在多核CPU系统中,每个...