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的介绍,同样,更新也更频繁. ...

随机推荐

Trainning Guide, Data Structures, Example
最近在复习数据结构,发现这套题不错,题目质量好,覆盖广,Data Structures部分包括Example,以及简单,中等,难三个部分,这几天把Example的做完了, 摘要如下: 通过这几题让我复 ...
Android安全问题抢先接收广播 - 内因篇之广播接收器注册流程
导读:本文说明系统是如何注册动态广播以及静态广播,这里主要注意其注册的顺序这篇文章主要是针对我前两篇文章 android安全问题抢先开机启动 - 结果篇 android安全问题抢先拦截短信 ...
WIFI(1)WIFI直连 + socket 可以用来实现类似蓝牙传输数据的功能
WIFI 直连简介从Android4.0(API Level=14)开始,允许通过Wi-Fi模块在两个移动设备之间建立直接连接(这种技术称为Wi-Fi Direct),这种连接不需要无线路由作为中介 ...
fiddler代理
对于前段开发人员,fiddler 是一个必不可少的调试神器.下载地址:http://www.telerik.com/download/fiddler. 有同学也许会碰到,chrome 下 fiddle ...
ORACLE SQLloader详细语法
Oracle SQL Loader的详细语法 SQL*LOADER是ORACLE的数据加载工具,通常用来将操作系统文件迁移到ORACLE数据库中.SQL*LOADER是大型数据 ...
设计模式Day02
1.生成器模式生成器模式也称为建造者模式.生成器模式的意图在于将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示. 生成器模式的编程步骤: (1)定义一个产品类: 由于不在该类完 ...
百度UEditor编辑器使用教程与使用方法
我们在做网站的时候,网站后台系统一般都会用到web编辑器,今天笔者就给大家推荐一款百度UEditor编辑器.关于这款百度UEditor编辑器官网上也有简单的教程,不过看着比较费劲,今天笔者就跟大家分享 ...
关于C#中static静态变量
C#静态变量使用static 修饰符进行声明,在类被实例化时创建,通过类进行访问不带有 static 修饰符声明的变量称做非静态变量,在对象被实例化时创建,通过对象进行访问一个类的所有实例的同一C#静 ...
hbase shell下如何使用删除键
今天刚安装好了hbase,通过Secure CRT登录hbase shell,敲入错误命令无法使用删除键(Backspace或是Ctrl+Backspace都不管用)删除,后来在终端-->仿真下 ...
Parallel stepped for loops in .NET C# z
; i < ; i += ) public IEnumerable<int> SteppedIntegerList(int startIndex, int endEndex, int ...

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

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

随机推荐

热门专题