现在的 *** 作系统是多任务 *** 作系统 多线程是实现多任务的一种方式
进程是指一个内存中运行的应用程序 每个进程都有自己独立的一块内存空间 一个进程中可以启动多个线程 比如在Windows系统中 一个运行的exe就是一个进程 线程是指进程中的一个执行流程 一个进程中可以运行多个线程 比如java exe进程中可以运行很多线程 线程总是属于某个进程 进程中的多个线程共享进程的内存 同时 执行是人的感觉 在线程之间实际上轮换执行
二 Java中的线程
在Java中 线程 指两件不同的事情
java lang Thread类的一个实例
线程的执行
使用java lang Thread类或者java lang Runnable接口编写代码来定义 实例化和启动新线程 一个Thread类实例只是一个对象 像Java中的任何其他对象一样 具有变量和方法 生死于堆上 Java中 每个线程都有一个调用栈 即使不在程序中创建任何新的线程 线程也在后台运行着 一个Java应用总是从main()方法开始运行 mian()方法运行在一个线程内 它被称为主线程 一旦创建一个新的线程 就产生一个新的调用栈 线程总体分两类 用户线程和守候线程
当所有用户线程执行完毕的时候 JVM自动关闭 但是守候线程却不独立于JVM 守候线程一般是由 *** 作系统或者用户自己创建的
———————————MultiT java——————————————————————
class MultiThread
{
public static void main(String[] args)
{
MyThread mt=new MyThread();
//mt setDaemon(true);//设定为后台线程 main进程结束时 后台进程也跟着结束
//mt setPriority(Thread MAX_PRIORITY); //设定线程优先级 MAX_PRIORITY为 MIN_PRIORITY为 NORM_PRIORITY为
//设定为最高优先级后 程序运行时 mt线程一直运行 强制终止时 main线程才运行
//设定为最高优先级的线程 无论有无yield(); 线程总一直运行 直到强制终止时 main和mt线程交替运行
mt start();
int index= ;
while(true) //显示结果与教程不同
{
if(index++== )
break;
System out println( main: +Thread currentThread() getName()); //获取线程名字
}
}
}
class MyThread extends Thread
{
public void run()
{
while(true)
{
System out println(getName());
yield(); //允许当前线程停止 转去执行其他线程 静态方法
//mt进程执行时 切换到main进程 main进程执行一段时间后
//切换进程到mt mt执行完获取名字后 返回到main进程
}
}
}
//一个长时间处于等待状态的线程也有可能被线程调度器调度 从而运行
//打破高优先级线程始终获有运行时间的状态
——————————————————————————————————————
——————————MultiThread java———————————————————————
class MultiThread
{
public static void main(String[] args)
{
MyThread mt=new MyThread();
//new Thread(mt) start(); //创建多个同样的线程访问同一个变量index 若MyThread采用继承Thread方式 则无法共享同一个变量
//new Thread(mt) start();
//new Thread(mt) start();
//new Thread(mt) start();
mt getThread() start(); //也可以采用内部类的方式共享访问同一个变量
mt getThread() start();
mt getThread() start();
mt getThread() start();
//mt setDaemon(true);//设定为后台线程 main进程结束时 后台进程也跟着结束
//mt setPriority(Thread MAX_PRIORITY); //设定线程优先级 MAX_PRIORITY为 MIN_PRIORITY为 NORM_PRIORITY为
//设定为最高优先级后 程序运行时 mt线程一直运行 强制终止时 main线程才运行
//设定为最高优先级的线程 无论有无yield(); 线程总一直运行 直到强制终止时 main和mt线程交替运行
//mt start();
int index= ;
while(true) //显示结果与教程不同
{
// if(index++== )
// break;
System out println( main: +Thread currentThread() getName()); //获取线程名字
}
}
}
class MyThread //implements Runnable //extends Thread //使用外部类的方式
//使用内部类完成使用Runnable接口才能完成的两个功能 a 创建多个线程 b 访问同一个变量
{
int index= ;
private class InnerThread extends Thread //不想让外部访问其实现方法 加上private
{
public void run()
{
while(true)
{
System out println(Thread currentThread() getName()+ : +index++);
}
}
}
Thread getThread()
{
return new InnerThread();
}
/
public void run()
{
while(true)
{
System out println(Thread currentThread() getName()+ : +index++);
//yield(); //允许当前线程停止 转去执行其他线程 静态方法
//mt进程执行时 切换到main进程 main进程执行一段时间后
//切换进程到mt mt执行完获取名字后 返回到main进程
}
}
/
}
//一个长时间处于等待状态的线程也有可能被线程调度器调度 从而运行
//打破高优先级线程始终获有运行时间的状态
//如果不需要修改Thread类的除了run方法外的其他方法 选用implements Runnable
———————————————————————————————————————
———————————TicketsSystem java———————————————————
//多线程实现火车票的售票系统 用同步块 或著同步方法
class TicketsSystem
{
public static void main(String[] args) //运行结果与教程中不同 不完全顺序 每次运行 顺序都不完全一样
{
SellThread st=new SellThread();//创建四个线程访问同一变量tickets
// 错 SellThread st =new SellThread();//若采用创建四个对象的方式 则每个对象中都有 张票
new Thread(st) start(); //b为false 用的同步方法 | //同步方法与同步块共用中 显示的是只调用了同步块 而同步方法未被调用
//b为true 用的同步块 | //原因 启动第一个线程后 CPU时间片没有到期 线程没有立即运行 接着执行b=true
// | //解决办法 启动第一个线程后 执行一个睡眠时间 让CPU时间片到期
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
st b=true;
new Thread(st) start();
//new Thread(st) start();
//new Thread(st) start();
}
}
class SellThread implements Runnable //程序有点小问题 当剩下最后一张票时 四个线程都运行 可能会出现票数为 （系统长时间运行时）
//可加上一个静态方法sleep();它会抛出异常
{
int tickets= ;
//Object obj=new Object();//也可以声明一个Thread对象
Thread th=new Thread();
boolean b=false;
public void run()
{
if(b==false)
{
while(true)
sell();
}
else
{
while(true)
{ //同步方法利用的是this所代表的对象的锁
synchronized(this) //采用同步后 显示正确 此方法两步 声明Thread对象 用synchronized把原方法括起来
{ //这里换th为this
///
if(tickets> )
{
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
System out println( th +Thread currentThread() getName()+ sell tickets: +tickets);
tickets ;
}
///
}
}
}
}
public synchronized void sell() //每个class也有一个锁 是这个class所对应的class对象的锁（监视器）
{
if(tickets> )
{
try
{
Thread sleep( );
}
catch(Exception e)
{
e printStackTrace();
}
System out println( sell +Thread currentThread() getName()+ sell tickets: +tickets);
tickets ;
}
}
}
————————————————————————————————————————
———————————TestWN java————————————————————
class Test
{
public static void main(String[] args)
{
Queue q=new Queue();
Producer p=new Producer(q);
Consumer c=new Consumer(q);
p start();
c start();
}
}
class Producer extends Thread
{
Queue q;
Producer(Queue q)
{
this q=q;
}
public void run()
{
for(int i= ;i< ;i++)
{
q put(i);
System out println( Producer put: +i);
}
}
}
class Consumer extends Thread
{
Queue q;
Consumer(Queue q)
{
this q=q;
}
public void run()
{
while(true)
{
System out println( Consumer get: +q get());
}
}
}
class Queue //wait notify 方法必须用在同步方法中 要加上关键字synchronized
{
int value;
boolean bFull=false;
public synchronized void put(int i)
{
if(!bFull)
{
value=i;
bFull=true;
notify();
}
try
{
wait();
}
catch(Exception e)
{
e printStackTrace();
}
}
public synchronized int get()
{
if(!bFull)
{
try
{
wait();
}
catch(Exception e)
{
e printStackTrace();
}
}
bFull=false;
notify();
return value;
}
}
————————————————————————————————————
————————————TestThread java———————————————————————
class TestThread
{
public static void main(String[] args)
{
Thread t =new Thread ();
t start();
int index= ;
while(true)
{
if(index++== )
{
t stopThread();
t interrupt(); //让线程 终止
break;
}
System out println(Thread currentThread() getName());
}
System out println( main() exit );
}
}
class Thread extends Thread
{
private boolean bStop=false;
public synchronized void run()
{
while(!bStop)
{
try
{
wait(); //加入wait后 main线程结束时 程序还未终止 原因是Thread 的线程调用wait方法 进入对象的等待队列中 需要notify方法将它唤醒
}
catch(Exception e)
{
//e printStackTrace();
if(bStop)
return;
}
System out println(getName());
}
}
public void stopThread()
{
bStop=true;
}
}
lishixinzhi/Article/program/Java/gj/201311/27407
public class FirstThread extends Thread
{
private int i ;
public void run()
{
//你把这里看清楚
for ( i=0; i < 100 ; i++ )
{
//Thread对象的getName返回当前该线程的名字
Systemoutprintln(getName() + " " + i);
}
}
public static void main(String[] args)
{
for (int i = 0; i < 100; i++)
{
//调用Thread的currentThread方法获取当前线程
Systemoutprintln(ThreadcurrentThread()getName() + " " + i);
if (i == 20)
{
//创建、并启动第一条线程
new FirstThread()start();
//创建、并启动第二条线程
new FirstThread()start();
}
}
}
}
main 0
main 1
main 2
main 3
main 4
main 5
main 6
main 7
main 8
main 9
main 10
main 11
main 12
main 13
main 14
main 15
main 16
main 17
main 18
main 19
main 20
main 21
main 22
main 23
main 24
main 25
main 26
main 27
main 28
main 29
main 30
main 31
main 32
main 33
main 34
main 35
main 36
main 37
main 38
main 39
main 40
main 41
main 42
main 43
main 44
main 45
main 46
main 47
main 48
main 49
main 50
main 51
main 52
main 53
main 54
main 55
main 56
main 57
main 58
main 59
main 60
main 61
main 62
main 63
main 64
main 65
main 66
main 67
main 68
main 69
main 70
main 71
main 72
main 73
main 74
main 75
main 76
main 77
main 78
main 79
main 80
main 81
main 82
main 83
main 84
main 85
main 86
main 87
main 88
main 89
main 90
main 91
main 92
main 93
main 94
main 95
main 96
main 97
main 98
main 99
Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
Thread-0 5
Thread-0 6
Thread-0 7
Thread-0 8
Thread-0 9
Thread-0 10
Thread-0 11
Thread-0 12
Thread-0 13
Thread-0 14
Thread-0 15
Thread-0 16
Thread-0 17
Thread-0 18
Thread-0 19
Thread-0 20
Thread-0 21
Thread-0 22
Thread-0 23
Thread-0 24
Thread-0 25
Thread-0 26
Thread-0 27
Thread-0 28
Thread-0 29
Thread-0 30
Thread-0 31
Thread-0 32
Thread-0 33
Thread-0 34
Thread-0 35
Thread-0 36
Thread-0 37
Thread-0 38
Thread-0 39
Thread-0 40
Thread-0 41
Thread-0 42
Thread-0 43
Thread-0 44
Thread-0 45
Thread-0 46
Thread-0 47
Thread-0 48
Thread-0 49
Thread-0 50
Thread-0 51
Thread-0 52
Thread-0 53
Thread-0 54
Thread-0 55
Thread-0 56
Thread-0 57
Thread-0 58
Thread-0 59
Thread-0 60
Thread-0 61
Thread-0 62
Thread-0 63
Thread-0 64
Thread-0 65
Thread-0 66
Thread-0 67
Thread-0 68
Thread-0 69
Thread-0 70
Thread-0 71
Thread-0 72
Thread-0 73
Thread-0 74
Thread-0 75
Thread-0 76
Thread-0 77
Thread-0 78
Thread-0 79
Thread-0 80
Thread-0 81
Thread-0 82
Thread-0 83
Thread-0 84
Thread-0 85
Thread-0 86
Thread-0 87
Thread-0 88
Thread-0 89
Thread-0 90
Thread-0 91
Thread-0 92
Thread-0 93
Thread-0 94
Thread-0 95
Thread-0 96
Thread-0 97
Thread-0 98
Thread-0 99
Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
Thread-1 5
Thread-1 6
Thread-1 7
Thread-1 8
Thread-1 9
Thread-1 10
Thread-1 11
Thread-1 12
Thread-1 13
Thread-1 14
Thread-1 15
Thread-1 16
Thread-1 17
Thread-1 18
Thread-1 19
Thread-1 20
Thread-1 21
Thread-1 22
Thread-1 23
Thread-1 24
Thread-1 25
Thread-1 26
Thread-1 27
Thread-1 28
Thread-1 29
Thread-1 30
Thread-1 31
Thread-1 32
Thread-1 33
Thread-1 34
Thread-1 35
Thread-1 36
Thread-1 37
Thread-1 38
Thread-1 39
Thread-1 40
Thread-1 41
Thread-1 42
Thread-1 43
Thread-1 44
Thread-1 45
Thread-1 46
Thread-1 47
Thread-1 48
Thread-1 49
Thread-1 50
Thread-1 51
Thread-1 52
Thread-1 53
Thread-1 54
Thread-1 55
Thread-1 56
Thread-1 57
Thread-1 58
Thread-1 59
Thread-1 60
Thread-1 61
Thread-1 62
Thread-1 63
Thread-1 64
Thread-1 65
Thread-1 66
Thread-1 67
Thread-1 68
Thread-1 69
Thread-1 70
Thread-1 71
Thread-1 72
Thread-1 73
Thread-1 74
Thread-1 75
Thread-1 76
Thread-1 77
Thread-1 78
Thread-1 79
Thread-1 80
Thread-1 81
Thread-1 82
Thread-1 83
Thread-1 84
Thread-1 85
Thread-1 86
Thread-1 87
Thread-1 88
Thread-1 89
Thread-1 90
Thread-1 91
Thread-1 92
Thread-1 93
Thread-1 94
Thread-1 95
Thread-1 96
Thread-1 97
Thread-1 98
Thread-1 99
成功生成（总时间：0 秒）
itjobJava老师讲过：1)线程堆栈概述及基础知识
2)线程堆栈的生成原理以及相关工具
3)不同JVM线程堆栈的格式的差异（SunHotSpot、IBMJRE、OracalJRockit）
4)线程堆栈日志介绍以及解析方法
5)线程堆栈的分析和相关的技术
6)常见的问题模板（线程竟态、死锁、IO调用挂死、垃圾回收/问题、死循环等）
7)线程堆栈问题实例分析
我希望这一系列的培训能给你带来确实的帮助，所以请持续关注每周的文章更新。
但是如果我在学习过程中有疑问或者无法理解文章中的内容该怎么办？
不用担心，把我当做你的导师就好。任何关于线程堆栈的问题都可以咨询我（前提是问题不能太low）。请随意选择下面的几种方式与我取得联系：
1)直接本文下面发表评论（不好意思的话可以匿名）
2)将你的线程堆栈数据提交到RootCauseAnalysisforum
3)发Email给我，地址是@@hotmail
能帮我分析我们产品上遇到的问题么？
当然可以，如果你愿意的话可以把你的堆栈现场数据通过邮件或论坛RootCauseAnalysisforum发给我。处理实际问题是才是学习提升技能的王道。
我真心期望大家能够喜欢这个培训。所以我会尽我所能去为你提供高质量的材料，并回答大家的各种问题。
在介绍线程堆栈分析技术和问题模式之前，先要给大家讲讲基础的内容。所以在这篇帖子里，我将先覆盖到最基本的内容，这样大家就能更好的去理解JVM、中间件、以及JavaEE容器之间的交互。
JavaVM概述
Java虚拟机是JaveEE平台的基础。它是中间件和应用程序被部署和运行的地方。
JVM向中间件软件和你的Java/JavaEE程序提供了下面这些东西:
_（二进制形式的）Java/JavaEE程序运行环境
_一些程序功能特性和工具(IO基础设施，数据结构，线程管理，安全，监控等等)
_借助垃圾回收的动态内存分配与管理
你的JVM可以驻留在许多的 *** 作系统(Solaris,AIX,Windows等等)之上，并且能根据你的物理服务器配置，你可以在每台物理/虚拟服务器上安装1到多个JVM进程
JVM与中间件之间的交互
下面这张图展示了JVM、中间件和应用程序之间的高层交互模型。
如你所见，标准JavaEE应用程序的线程的分配实在中间件内核与JVM之间完成的。（当然也有例外，应用程序可以直接调用API来创建线程，这种做法并不常见，而且在使用的过程中也要特别的小心）
同时，请注意一些线程是由JVM内部来进行管理的，典型的例子就是垃圾回收线程，JVM内部使用这个线程来做并行的垃圾回收处理。
因为大多数的线程分配都是由JavaEE容器完成的，所以能够理解和认识线程堆栈跟踪，并能从线程堆栈数据中识别出它来，对你而言很重要这可以让你能够快速的知道JavaEE容器正要执行的是什么类型的请求
从一个线程转储堆栈的分析角度来看，你将能了解从JVM发现的线程池之间的不同，并识别出请求的类型
最后一节会向你提供对于HotSopVM而言什么是JVM线程堆栈的一个概述，还有你将会遇到的各种不同的线程而对IBMVM线程堆栈形式详细内容将会在第四节向你提供
请注意你可以从根本原因分析论坛获得针对本文的线程堆栈示例
JVM线程堆栈——它是什么
JVM线程堆栈是一个给定时间的快照，它能向你提供所有被创建出来的Java线程的完整清单
package a;
class A implements Runnable{
Thread t;
A(){
t=new Thread(this);
tstart();
}
@Override
public void run() {
for (int i=1;i<=3;i++){
try {
Threadsleep(1000);
Systemoutprintln(3-i);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
eprintStackTrace();
}
}
Systemoutprintln("线程A停止了");
}
}
class B{
public void show(){
A a =new A();
for (int i=1;i<=10;i++){
try {
Threadsleep(500);
} catch (InterruptedException e) {
eprintStackTrace();
}
Systemoutprintln(atisAlive());
}
}
}
public class aaaaaaa{
public static void main(String args[]){
B b=new B();
bshow();
}
}
希望对您有帮助，我的QQ1181513953，可以共同交流，呵呵。
--------------------------第一个类----------------------------------------------------------
/
@author songhaitian
该线程计算12+23+6
/
public class FirstThread implements Runnable{
private Long result;
public FirstThread(Long result){
thisresult=result;
}
@Override
public void run() {
int i=1;
while (i<1999) {
synchronized (this) {//此处需要同步，否则会出现线程二读取的与此处设置的不一致的状况
result=result+i(++i);
setResult(result);
Systemoutprintln("Thread1将result置为："+result);
}
try {
Threadsleep(1000);
} catch (InterruptedException e) {
eprintStackTrace();
}
}
}
public Long getResult() {
return result;
}
public void setResult(Long result) {
thisresult = result;
}
}
--------------------------第二个类----------------------------------------------------------
import javautilRandom;
/
该类持有一个FirstThread类型的实例。
该类从持有的FirstThread实例中获取计算的结果并输出。
/
public class SecondThread implements Runnable{
private FirstThread firstThread;
@Override
public void run() {
Random random=new Random();
try {
while (firstThreadgetResult()<=10000) {//为了简单起见，最大输出到10000
Threadsleep(randomnextInt(30));
synchronized (firstThread) {//此处需要同步，否则会出现线程一设置的与此处读取的不一致的状况
Systemoutprintln("从FirstThread获取的当前值："+firstThreadgetResult()longValue());
}
}
} catch (InterruptedException e) {
eprintStackTrace();
}
}
public SecondThread(FirstThread firstThread) {
super();
thisfirstThread = firstThread;
}
public FirstThread getFirstThread() {
return firstThread;
}
public void setFirstThread(FirstThread firstThread) {
thisfirstThread = firstThread;
}
}
-----------------------------第三个类-测试类----------------------------
/
测试类，根据此类可以看出运行结果。
/
public class Test {
public static void main(String[] args) {
FirstThread firstThread=new FirstThread(0l);
Thread thread1=new Thread(firstThread);
Thread thread2=new Thread(new SecondThread(firstThread));
thread1start();
thread2start();
}
}
---------------------运行结果-----------------------------------------
Thread1将result置为：2
从FirstThread获取的当前值：2
Thread1将result置为：8
从FirstThread获取的当前值：8
从FirstThread获取的当前值：8
从FirstThread获取的当前值：8
Thread1将result置为：20
从FirstThread获取的当前值：20
Thread1将result置为：40
从FirstThread获取的当前值：40
从FirstThread获取的当前值：40
Thread1将result置为：70
从FirstThread获取的当前值：70
从FirstThread获取的当前值：70
Thread1将result置为：112
从FirstThread获取的当前值：112
从FirstThread获取的当前值：112
Thread1将result置为：168
从FirstThread获取的当前值：168
从FirstThread获取的当前值：168
从FirstThread获取的当前值：168
Thread1将result置为：240
从FirstThread获取的当前值：240
………………………………
以上就是关于Java线程的概念与原理全部的内容，包括:Java线程的概念与原理、JAVA线程问题、你如何在Java中获取线程堆栈等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）