java学习之路---线程（重点）

1.多线程是一种并发机制的有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的一种实现单位，线程是在进程的基础上的进一步划分。所谓的多线就是在一个进程中产生了多个线程，这些线程可以同时存在，同时运行。

2.多线程的实现

1.继承Thread类

2.实现runnable接口

3.继承Thread类

public
class
ThreadDemo
extends
Thread{

private
String
userName
;

public
String getUserName() {

return
userName
;

}

public
void
setUserName(String userName) {

this
.
userName
= userName;

}

public
ThreadDemo(String userName) {

this
.
userName
= userName;

}

@Override

public
void
run() {

for
(
int
i=1;i<10;i++){

System.
out
.println(
userName
+i);

}

public
static
void
main(String[] args) {

ThreadDemo threadDemo=
new
ThreadDemo (
"线程A"
);

ThreadDemo threadDemo1=
new
ThreadDemo (
"线程B"
);

threadDemo.run();

threadDemo1.run();

}

结果：

线程A1

线程A2

线程A3

线程A4

线程A5

线程A6

线程A7

线程A8

线程A9

线程B1

线程B2

线程B3

线程B4

线程B5

线程B6

线程B7

线程B8

线程B9

发现并没有实现多线程，如果要正确的启动多线程，则要调用start方法。

代码：

public
class
ThreadDemo
extends
Thread{

private
String
userName
;

public
String getUserName() {

return
userName
;

}

public
void
setUserName(String userName) {

this
.
userName
= userName;

}

public
ThreadDemo(String userName) {

this
.
userName
= userName;

}

@Override

public
void
run() {

for
(
int
i=1;i<10;i++){

System.
out
.println(
userName
+i);

}

public
static
void
main(String[] args) {

ThreadDemo threadDemo=
new
ThreadDemo (
"线程A"
);

ThreadDemo threadDemo1=
new
ThreadDemo (
"线程B"
);

threadDemo.start();

threadDemo1.start();

}

结果（这只是其中的一种）：

线程A1

线程B1

线程A2

线程B2

线程A3

线程B3

线程A4

线程A5

线程A6

线程A7

线程B4

线程A8

线程A9

线程B5

线程B6

线程B7

线程B8

线程B9

为什么要调用start,而不是调用run方法喃？

看源码:

public
synchronized
void
start() {

/**

* This method is not invoked for the main method thread or "system"

* group threads created/set up by the VM. Any new functionality added

* to this method in the future may have to also be added to the VM.

* A zero status value corresponds to state "NEW".

if
(
threadStatus
!= 0)

throw
new
IllegalThreadStateException();

/* Notify the group that this thread is about to be started

* so that it can be added to the group's list of threads

* and the group's unstarted count can be decremented. */

group
.add(
this
);

boolean
started =
false
;

try
{

start0();

started =
true
;

}
finally
{

try
{

if
(!started) {

group
.threadStartFailed(
this
);

}

}
catch
(Throwable ignore) {

/* do nothing. If start0 threw a Throwable then

it will be passed up the call stack */

}

private
native
void
start0();

返现这里的start0()用了 native ,这个关键字表示调用本机的操作系统函数，因为多线程需要底层操作系统的支持。

如果一个类继承了Thread类，那么一个对象就只能调用一次，如果调用多次，则会抛出异常

public
class
ThreadDemo
extends
Thread{

private
String
userName
;

public
String getUserName() {

return
userName
;

}

public
void
setUserName(String userName) {

this
.
userName
= userName;

}

public
ThreadDemo(String userName) {

this
.
userName
= userName;

}

@Override

public
void
run() {

for
(
int
i=1;i<10;i++){

System.
out
.println(
userName
+i);

}

public
static
void
main(String[] args) {

ThreadDemo threadDemo=
new
ThreadDemo(
"线程A"
);

ThreadDemo threadDemo1=
new
ThreadDemo(
"线程B"
);

threadDemo.start();

}

结果：

线程A1

线程A2

线程A3

线程A4

线程A5

线程A6

线程A7

Exception in thread "main"
java.lang.IllegalThreadStateException

at java.lang.Thread.start(
Thread.java:682
)

at test.ThreadDemo.main(
ThreadDemo.java:34
)

线程A8

线程A9

所以如果一个类继承Thread类,想要实现多线程，就有单继承的局限性，所以最好实现runnable接口

4.实现runnable 接口

class
MyTread
implements
Runnable{

private
Integer
ticket
=10;

public
void
run() {

fun();

}

public
synchronized
void
fun(){

for
(
int
i=0;i<100;i++){

if
(
ticket
>0){

System.
out
.println(
"卖票: ticket="
+
ticket
--);

}

};

public
class
ThreadDemo1{

public
static
void
main(String[] args) {

MyTread myTread=
new
MyTread();

new
Thread(myTread).start();

}

这样写：

可以实现多线程的访问（下面的结果是因为锁的原因）

结果：

卖票: ticket=10

卖票: ticket=9

卖票: ticket=8

卖票: ticket=7

卖票: ticket=6

卖票: ticket=5

卖票: ticket=4

卖票: ticket=3

卖票: ticket=2

卖票: ticket=1

如果代码改为这样：

class
MyTread
implements
Runnable{

private
Integer
ticket
=10;

public
void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0)

System.
out
.println(
"票号"
+
ticket
--);

}

public
class
ThreadDemo1{

public
static
void
main(String[] args) {

MyTread myTread=
new
MyTread();

new
Thread(myTread).start();

}

结果：（不唯一）

票号10

票号8

票号9

票号6

票号4

票号3

票号2

票号1

票号7

票号5

5.线程的状态

线程有五种状态

创建状态：一个线程被创建后就处于创建状态，此时它拥有了相应的内存空间和其他资源，但是还处于不可运行状态

就绪状态：当调用线程的时候就进入就绪状态，此时，它将进入线程队列排队，等待CPU服务。

运行状态：CPU调用该资源，自动调用该线程对象的run方法

阻塞状态：CPU暂时中止此线程的进行。

死亡：线程调用stop()或者run()方法运行完成后

6.线程的相关方法

应用方法代码：

取得线程名称：

class
MyTread
implements
Runnable{

private
Integer
ticket
=10;

public

void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0)

System.
out
.println(Thread.currentThread().getName()+
"票号"
+
ticket
-- );//取得线程名称，如果自己没有给名称，那么程序就会自动付给一个名称

看源码：

public
Thread (Runnable target) {

init(
null
, target,
"Thread-"
+ nextThreadNum(), 0);

}

private

static

synchronized
int
nextThreadNum () {

return

threadInitNumber
++;

}

public

class
ThreadDemo1 {

public

static
void
main(String[] args) {

MyTread myTread=
new
MyTread();

new
Thread(myTread).start();

}

结果：

Thread-1票号10

Thread-0票号9

Thread-1票号8

Thread-2票号6

Thread-0票号7

Thread-2票号4

Thread-1票号5

Thread-2票号2

Thread-0票号3

Thread-1票号1

如果给了名称：

class
MyTread
implements
Runnable{

private
Integer
ticket
=10;

public

void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0)

System.
out
.println(Thread.currentThread().getName()+
"票号"
+
ticket
-- );

}

public

class
ThreadDemo1 {

public

static
void
main(String[] args) {

MyTread myTread=
new
MyTread();

new
Thread(myTread,
"A线程"
).start();
//自己给线程名称

new
Thread(myTread,
"like"
).start();

new
Thread(myTread).start();

}

结果：

like票号10

like票号9

like票号7

like票号6

A线程票号8

Thread-0票号4

like票号5

Thread-0票号2

A线程票号3

like票号1

补充：

java程序启动的时候至少启动两个程序，一个是：main,一个是垃圾回收机制

线程的休眠：

class
MyTread
implements
Runnable{

private
Integer
ticket
=10;

public

void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0){

try
{

Thread. sleep(1000);//这里休眠1000ms==1S

}
catch
(InterruptedException e) {

e.printStackTrace();

}

System.
out
.println(Thread.currentThread().getName()+
"票号"
+
ticket
-- );

}

public

class
ThreadDemo1 {

public

static
void
main(String[] args) {

MyTread myTread=
new
MyTread();

new
Thread(myTread,
"A线程"
).start();
//自己给线程名称

new
Thread(myTread,
"like"
).start();

new
Thread(myTread).start();

}

自己打印结果的时候：就会发现有停顿：

like票号10

A线程票号10

Thread-0票号9

like票号8

A线程票号7

Thread-0票号6

like票号5

A线程票号4

Thread-0票号3

like票号2

A线程票号2

Thread-0票号1

like票号0

A线程票号-1

这里出现了-1，是因为在if(ticket>0)判断的时候，上一个线程还没有
ticket
-- ，而另一个线程就已经进入

判断线程是否启动：

class
MyTread
implements
Runnable{

private
Integer
ticket
=10;

public

void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0){

try
{

Thread. sleep(1000);

}
catch
(InterruptedException e) {

e.printStackTrace();

}

System.
out
.println(Thread. currentThread().getName()+
"票号"
+
ticket
-- );

}

public

class
ThreadDemo2 {

public

static

void
main(String[] args) {

MyTread myTread=
new
MyTread();

Thread t=
new
Thread(myTread,
"A线程"
);
//自己给线程名称

System.
out
.println (
"线程是否启动"
+t.isAlive());

t.start();
//启动线程

System.
out
.println (
"线程是否启动"
+t.isAlive());

new
Thread(myTread,
"like"
).start();

new
Thread(myTread).start();

}

结果：

线程是否启动false

线程是否启动true

like票号10

A线程票号10

Thread-0票号9

A线程票号8

like票号7

Thread-0票号6

A线程票号5

like票号4

Thread-0票号3

A线程票号2

like票号1

Thread-0票号0

A线程票号-1

线程的强制进行：

class
MyTread
implements
Runnable{

private
Integer
ticket
=10;

public

void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0){

try
{

Thread. sleep(1000);

}
catch
(InterruptedException e) {

e.printStackTrace();

}

System.
out
.println(Thread.currentThread().getName()+
"票号"
+
ticket
-- );

}

public

class
ThreadDemo2 {

public

static

void
main(String[] args) {

MyTread myTread=
new
MyTread();

Thread t=
new
Thread(myTread,
"A线程"
);
//自己给线程名称

System.
out
.println(
"线程是否启动"
+t.isAlive());

t.start();
//启动线程

for
(
int
i=0;i<10;i++){

if
(i>2){

try
{

t.join();
//线程的强制惊醒

}
catch
(InterruptedException e) {

//
TODO
Auto-generated catch block

e.printStackTrace();

}

System.
out
.println(
"线程是否启动"
+t.isAlive());

new
Thread(myTread,
"like"
).start();

new
Thread(myTread).start();

}

结果：

线程是否启动false

A线程票号10

A线程票号9

A线程票号8

A线程票号7

A线程票号6

A线程票号5

A线程票号4

A线程票号3

A线程票号2

A线程票号1

线程是否启动false

为什么第二次判断也是false，那是因为，线程A已经执行完毕，所以已经死亡，自然是false

线程的中止：

class
MyTread1
implements
Runnable{

private
Integer
ticket
=10;

public

void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0){

try
{

Thread. sleep(3000);

}
catch
(InterruptedException e) {

System.
out
.println(
"A线程被中止"
);

return
;

}

System.
out
.println(Thread.currentThread().getName()+
"票号"
+
ticket
-- );

}

public

class
ThreadDemo2 {

public

static

void
main(String[] args) {

MyTread1 myTread=
new
MyTread1();

Thread t=
new
Thread(myTread,
"A线程"
);
//自己给线程名称

System.
out
.println(
"线程是否启动"
+t.isAlive());

t.start();
//启动线程

try
{

Thread. sleep(2000);

}
catch
(InterruptedException e) {

//
TODO
Auto-generated catch block

e.printStackTrace();

}

t.interrupt();

System.
out
.println(
"线程是否启动"
+t.isAlive());

new
Thread(myTread,
"like"
).start();

new
Thread(myTread).start();

}

结果：

线程是否启动false

线程是否启动true

A线程被中止

like票号10

Thread-0票号9

like票号8

Thread-0票号7

like票号6

Thread-0票号5

like票号4

Thread-0票号3

like票号2

Thread-0票号1

后台线程：

t.setDaemon(
true
);

7.线程的优先级

class
MyTread1
implements
Runnable{

private
Integer
ticket
=10;

public

void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0){

try
{

Thread. sleep(100);

}
catch
(InterruptedException e) {

System.
out
.println(
"A线程被中止"
);

}

System.
out
.println(Thread.currentThread().getName()+
"票号"
+
ticket
-- );

}

public

class
ThreadDemo2 {

public

static

void
main(String[] args) {

MyTread1 myTread=
new
MyTread1();

Thread t=
new
Thread(myTread,
"A线程"
);
//自己给线程名称

Thread t1=
new
Thread(myTread,
"like"
);

Thread t2=
new
Thread(myTread);

t.setPriority(Thread.
MAX_PRIORITY
);
//设置线程优先级，最大10

t1.setPriority(Thread.
MIN_PRIORITY
);最小1

t2.setPriority(Thread.
NORM_PRIORITY
);5

t1.start();

t.start();
//启动线程

t2.start();

}

结果：

like票号10

A线程票号8

Thread-0票号9

Thread-0票号7

like票号6

A线程票号5

Thread-0票号4

like票号3

A线程票号2

Thread-0票号1

A线程票号0

like票号-1

这说明不是绝对那个线程的优先级高，就调用那个，而是要看CPU的调度

public

class
ThreadDemo2 {

public

static

void
main(String[] args) {

// MyTread1 myTread=new MyTread1();

// Thread t= new Thread(myTread,"A线程");//自己给线程名称

// Thread t1= new Thread(myTread,"like");

// Thread t2= new Thread(myTread);

// t.setPriority(Thread.MAX_PRIORITY);//设置线程优先级

// t1.setPriority(Thread.MIN_PRIORITY);

// t2.setPriority(Thread.NORM_PRIORITY);

// t1.start();

// t.start();//启动线程

// t2.start();

System.
out
.println(Thread.currentThread().getPriority());
//获取主方法的优先级

}

结果：

8.线程的礼让：（让当前的线程暂时让个其他线程）

class
MyTread1
implements
Runnable{

private
Integer
ticket
=10;

public

void
run() {

for
(
int
i=0;i<100;i++){

if
(
ticket
>0){

System.
out
.println(Thread.currentThread().getName()+
"----->"
);
//获取线程的名字

if
(
ticket
==3){

System.
out
.print(
"线程礼让："
);

Thread.currentThread ().yield();

}

System.
out
.println(Thread.currentThread().getName()+
"票号"
+
ticket
-- );

}

public

class
ThreadDemo2 {

public

static

void
main(String[] args) {

MyTread1 myTread=
new
MyTread1();

Thread t=
new
Thread(myTread,
"A线程"
);
//自己给线程名称

Thread t1=
new
Thread(myTread,
"like"
);

Thread t2=
new
Thread(myTread);

t.setPriority(Thread.
MAX_PRIORITY
);
//设置线程优先级

t1.setPriority(Thread.
MIN_PRIORITY
);

t2.setPriority(Thread.
NORM_PRIORITY
);

t1.start();

t.start();
//启动线程

t2.start();

}

结果：

A线程----->

like----->

Thread-0----->

Thread-0票号8

A线程票号10

like票号9

Thread-0----->

like----->

A线程----->

A线程票号5

like票号6

like----->

like票号4

like----->

线程礼让：like票号3

like----->

like票号2

like----->

like票号1

Thread-0票号7

A线程----->

A线程票号0

看看结果：当线程like让出当前线程，但是下一个执行的线程还是like线程，这说明线程的礼让不是绝对的，不是礼让了就一定会让给其他线程

java学习之路---线程（重点）的更多相关文章

Java学习之路（转）
Java学习之路(书籍推荐) 一.基础类 1.<Thinking in java>(阅读2遍),入门第一位是建立正确的概念 2.<Core Java>这本书更贴近实践,更多 ...
新篇章之我的java学习之路下
昨天写下了人生的第一篇博客,今天接着写我的java学习之路有关开发及框架的学习过程. 想要学好java语言,只学习一些java的基本语法对实际开发中的用处还是不大的,所以我们还要掌握一些有关javaW ...
java学习之路之javaSE基础2
java学习之路之javaSE基础2 所有的代码都是引用他人写的. 1.逻辑运算符 //&,|,^,! //int x = 10; //5 < x < 15 //x > 5 ...
java学习之路之javaSE基础1
<h2>java学习之路之javaSE基础1</h2> <div> ###01.01_计算机基础知识(计算机概述)(了解)* A:什么是计算机?计算机在生活中的应用 ...
java学习笔记15--多线程编程基础2
本文地址:http://www.cnblogs.com/archimedes/p/java-study-note15.html,转载请注明源地址. 线程的生命周期 1.线程的生命周期线程从产生到消亡 ...
JAVA学习之路与大家分享
这是我四年以前总结的JAVA学习之路,希望对初学者或想从事JAVA开发的人有帮助. 本人是软件工程专业出身,先后学过C.C++.JAVA.VB.delphi等等开发语言以及网络相关管理技术.哎,好久不 ...
Java 学习之路 -- day00
Java 学习之路 -- day00 Typora 快捷键操作标题:#+空格 2. *斜体* 3. **加粗** 4. **斜体加粗*** 5. ~~删除线~~ 6. > 引用 7. ···分 ...
（转）如何学习Java技术？谈Java学习之路
51CTO编者注:这篇文章已经是有数年“网龄”的老文,不过在今天看来仍然经典.如何学习Java?本篇文章可以说也是面对编程初学者的一篇指导文章,其中对于如何学习Java的步骤的介绍,很多也适用于开发领 ...
Java学习之路（书籍推荐）
一.基础类 1.<Thinking in java>(阅读2遍),入门第一位是建立正确的概念 2.<Core Java>这本书更贴近实践,更多API的介绍,同样,更新也更频繁. ...

随机推荐

Android ActionBar通过Tab进行不同的Fragment之间的交换
ActionBar的使用常见于4.0系统,其Tab的使用挺广泛的. 在ActionBar中添加标签(Tabs),每个标签对应的是一个Fragment,点击不同的Tab时,就会切换到对应的Fragmen ...
Android安全问题静音拍照与被拍
之前写过一些android手机root之后的安全问题的(文章列表见末尾),其实我是想到哪就写到了,今天整理硬盘,发现一年之前写过一段代码,所以今天我们就一起来讨论一下. 注:这里不是讨论多nb的技术, ...
理解 PHP 中的 Streams
Streams 是PHP提供的一个强有力的工具,我们常常在不经意会使用到它,如果善加利用将大大提高PHP的生产力. 驾驭Streams的强大力量后,应用程序将提升到一个新的高度. 下面是PHP手册中对 ...
Java汉字排序(3)按笔划排序
对于包含汉字的字符串来说,排序的方式主要有两种:一种是拼音,一种是笔画. 本文就讲述如何实现按笔划排序的比较器(Comparator). 作者:Jeff 发表于:2007年12月21日 11:27 最 ...
Android开发之多媒体编程之加载大分辨率图片
Android中图片占用内存的大小=图片的总像数*每个像数占用的大小. Android保存图片像素信息使用ARGB,意思是每个像素占用4个字节. 以分辨率为2400*3200的图片来说,加载到Andr ...
Unity NGUI弧形血条的制作
unity版本:4.6 NGUI版本:3.6. (转载请注明参考链接及作者) 参考链接:http://www.cnblogs.com/louissong/p/3841656.html,作者:博客园 L ...
Innodb 锁系列2 事务锁
上一篇介绍了Innodb的同步机制锁:Innodb锁系列1 这一篇介绍一下Innodb的事务锁,只所以称为事务锁,是因为Innodb为实现事务的ACID特性,而添加的表锁或者行级锁. 这一部分分两篇来 ...
宏HASH_DELETE
HASH_DELETE(buf_page_t, hash, buf_pool->page_hash, fold, bpage); NAME 可理解为 void* next /********** ...
使用Unity3D自带动画系统制作下雨效果
之前看了以前版本的unity3d demo AngryBots ,觉得里面的下雨效果不错,刚好前段时间学习了,写出来跟大家分享下,直接开始. 使用自带动画系统制作下雨效果. 先制作下雨的雨滴涟漪步骤 ...
关于 tomcat 集群中 session 共享的三种方法
前两种均需要使用 memcached 或redis 存储 session ,最后一种使用 terracotta 服务器共享. 建议使用 redis,不仅仅因为它可以将缓存的内容持久化,还因为它支持的单 ...

java学习之路---线程（重点）

java学习之路---线程（重点）的更多相关文章

随机推荐

热门专题