Thread类中的其他常用方法
获取当前线程名称
方式一：
this.getName()获取线程名称，该方法适用于继承
Thread
实现多线程方式。
class GetName1 extends Thread{
@Override
public void run() {
System.out.println(this.getName());
}
}
方式二：
Thread.currentThread().getName()获取线程名称，该方法适用于实现Runnable
接口实现多线程方式。
class GetName2 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}设置线程的名称
方式一：
通过构造方法设置线程名称。
class SetName1 extends Thread{
public SetName1(String name){
super(name);
}
@Override
public void run() {
System.out.println(this.getName());
}
}
public class SetNameThread {
public static void main(String[] args) {
SetName1 setName1 = new SetName1("SetName1");
setName1.start();
}
}
方式二：
通过setName()
方法设置线程名称。
class SetName2 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
public class SetNameThread {
public static void main(String[] args) {
Thread thread = new Thread(new SetName2());
thread.setName("SetName2");
thread.start();
}
}判断线程是否存活
isAlive()方法： 判断当前的线程是否处于活动状态。
活动状态是指线程已经启动且尚未终止，线程处于正在运行或准备开始运行的状态，就认为线程是存活的
class Alive implements Runnable{
@Override
public void run() {
for(int i=0;i<4;i++){
System.out.println(Thread.currentThread().getName()+" "+i);
try {
Thread.sleep(500);
} catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
public class TestAliveThread {
public static void main(String[] args) {
Thread thread = new Thread(new Alive());
thread.setName("Alive");
thread.start();
System.out.println(thread.getName()+""+thread.isAlive());
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(thread.getName()+""+thread.isAlive());
}
}线程的优先级
什么是线程的优先级
每一个线程都是有优先级的，我们可以为每个线程定义线程的优先级，但是这并不能保证高优先级的线程会在低优先级的线程前执行。线程的优先级用数字表示，范围从1到
10
，一个线程的缺省优 先级是5
。
Java 的线程优先级调度会委托给操作系统去处理，所以与具体的操作系统优先级有关，如非特别需要，一般无需设置线程优先级。
注意线程的优先级，不是说哪个线程优先执行，如果设置某个线程的优先级高。那就是有可能被执行的概率高。并不是优先执行。
线程优先级的使用
使用下列方法获得或设置线程对象的优先级。int getPriority();void setPriority(int newPriority);
注意：优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高的线程后调用优先级低的线程。
class Priority implements Runnable{
private int num = 0;
private boolean flag = true;
@Override
public void run() {
while(this.flag){
System.out.println(Thread.currentThread().getName()+" "+num++);
}
}
public void stop(){
this.flag = false;
}
}
public class PriorityThread {
public static void main(String[]args)throws Exception {
Priority p1 = new Priority();
Priority p2 = new Priority();
Thread t1 = new Thread(p1,"线程1");
Thread t2 = new Thread(p2,"线程2");
System.out.println(t1.getPriority());
//Thread.MAX_PRIORITY = 10
t1.setPriority(Thread.MAX_PRIORITY);
//Thread.MAX_PRIORITY = 1
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
Thread.sleep(1000);
p1.stop();
p2.stop();
}
}守护线程
什么是守护线程
在 Java 中有两类线程：User Thread(用户线程 ) ：就是应用程序里的自定义线程。Daemon Thread(守护线程 ) ：比如垃圾回收线程，就是最典型的守护线程。
守护线程（即Daemon Thread
），是一个服务线程，准确地来说就是服务其他的线程，这是它的作用，而其他的线程只有一种，那就是用户线程。
守护线程特点： 守护线程会随着用户线程死亡而死亡。
守护线程与用户线程的区别：用户线程，不随着主线程的死亡而死亡。用户线程只有两种情况会死掉，1在 run 中异常终止。 2 正常把 run 执行完毕，线程死亡。守护线程，随着用户线程的死亡而死亡，当用户线程死亡守护线程也会随之死亡
/**
* 守护线程类
*/
class Daemon implements Runnable{
@Override
public void run() {
for(int i=0;i<20;i++){
System.out.println(Thread.currentThread().getName()+" "+i);
try {
Thread.sleep(2000);
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
class UsersThread implements Runnable{
@Override
public void run() {
Thread t = new Thread(new Daemon(),"Daemon");
//将该线程设置为守护线程
t.setDaemon(true);
t.start();
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+" "+i);
try {
Thread.sleep(500);
} catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
public class DaemonThread {
public static void main(String[]args)throws Exception {
Thread t = new Thread(new UsersThread(),"UsersThread");
t.start();
Thread.sleep(1000);
System.out.println("主线程结束");
}
}线程同步
什么是线程同步
线程冲突现象：
同步问题的提出：
现实生活中，我们会遇到“
同一个资源，多个人都想使用
”
的问题。比如：教室里，只有一台电脑，多个人都想使用。天然的解决办法就是，在电脑旁边，大家排队。前一人使用完后，后一人再使用。
线程同步的概念：
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。 这时候，我们就需要用到“线程同步
”
。 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用
实现线程同步 ：
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问造成的这种问题。这套机制就是synchronized
关键字。
synchronized 语法结构：synchronized( 锁对象 ){同步代码}
synchronized 关键字使用时需要考虑的问题：需要对那部分的代码在执行时具有线程互斥的能力( 线程互斥：并行变串行 ) 。需要对哪些线程中的代码具有互斥能力( 通过 synchronized 锁对象来决定 ) 。
它包括两种用法：
synchronized
方法和
synchronized
块。
synchronized
方法
通过在方法声明中加入 synchronized 关键字来声明，语法如下：public synchronized void accessVal ( int newVal );
synchronized 在方法声明时使用：放在访问控制符
(public)
之前或之后。这时同一个对象下synchronized
方法在多线程中执行时，该方法是同步的，即一次只能有一个线程进入该方法，其他 线程要想在此时调用该方法，只能排队等候，当前线程(
就是在synchronized方法内部的线程
)
执行完该方法后，别的线程才能进入。
synchronized
块
synchronized 方法的缺陷：若将一个大的方法声明为 synchronized 将会大大影响效率。Java 为我们提供了更好的解决办法，那就是
synchronized
块。块可以让我们精确地控制到具体的“
成员变量
”
，缩小同步的范围，提高效率
使用this作为线程对象锁
语法结构：synchronized ( this ){// 同步代码}
或
public synchronized void accessVal ( int newVal ){// 同步代码}
/**
* 定义程序员类
*/
class Programmer{
private String name;
public Programmer(String name){
this.name = name;
} /**
* 打开电脑
*/
synchronized public void computer(){
try {
System.out.println(this.name+ " 接通电源");
Thread.sleep(500);
System.out.println(this.name+ " 按开机按键");
Thread.sleep(500);
System.out.println(this.name+ " 系统启动中");
Thread.sleep(500);
System.out.println(this.name+ " 系统启动成功");
} catch (InterruptedException e){
e.printStackTrace();
}
}
/**
* 编码
*/
synchronized public void coding(){
try {
System.out.println(this.name+ " 双击Idea");
Thread.sleep(500);
System.out.println(this.name+ " Idea启动完毕");
Thread.sleep(500);
System.out.println(this.name+ " 开开心心的写代码");
} catch (InterruptedException e){
e.printStackTrace();
}
}
}
/**
* 打开电脑的工作线程
*/
class Working1 extends Thread{
private Programmer p;
public Working1(Programmer p){
this.p = p;
}
@Override
public void run() {
this.p.computer();
}
}
/**
* 编写代码的工作线程
*/
class Working2 extends Thread{
private Programmer p;
public Working2(Programmer p){
this.p = p;
}
@Override
public void run() {
this.p.coding();
}
}
public class TestSyncThread {
public static void main(String[] args) {
Programmer p = new Programmer("张三");
new Working1(p).start();
new Working2(p).start();
}
}使用字符串作为线程对象锁
语法结构：synchronized ( “ 字符串 ” ){// 同步代码}
/**
* 定义程序员类
*/
class Programmer{
private String name;
public Programmer(String name){
this.name = name;
}
/**
* 打开电脑
*/
synchronized public void computer(){
try {
System.out.println(this.name + " 接通电源");
Thread.sleep(500);
System.out.println(this.name + " 按开机按键");
Thread.sleep(500);
System.out.println(this.name + " 系统启动中");
Thread.sleep(500);
System.out.println(this.name + " 系统启动成功");
} catch (InterruptedException
{
e.printStackTrace();
}
}
/**
* 编码
*/
synchronized public void coding(){ try {
System.out.println(this.name + " 双击Idea");
Thread.sleep(500);
System.out.println(this.name + " Idea启动完毕");
Thread.sleep(500);
System.out.println(this.name + " 开开心心的写代码");
} catch (InterruptedException) {
e.printStackTrace();
}
}
/**
* 去卫生间
*/
public void wc(){
synchronized ("suibian") {
try {
System.out.println(this.name + " 打开卫生间门");
Thread.sleep(500);
System.out.println(this.name + " 开始排泄");
Thread.sleep(500);
System.out.println(this.name + " 冲水");
Thread.sleep(500);
System.out.println(this.name + " 离开卫生间");
} catch (InterruptedException) {
e.printStackTrace();
}
}
}
}
/**
* 打开电脑的工作线程
*/
class Working1 extends Thread{
private Programmer p;
public Working1(Programmer p){
this.p = p;
}
@Override
public void run() {
this.p.computer();
}
}
/**
* 编写代码的工作线程
*/
class Working2 extends Thread{
private Programmer p;
public Working2(Programmer p){
this.p = p;
}
@Override
public void run() {
this.p.coding();
}
}
/**
* 去卫生间的线程
*/
class WC extends Thread{
private Programmer p;
public WC(Programmer p){
this.p = p;
}
@Override
public void run() {
this.p.wc();
}
}
public class TestSyncThread {
public static void main(String[] args){
Programmer p = new Programmer("秃头");
Programmer p1 = new Programmer("李四");
Programmer p2 = new Programmer("王五");
new WC(p).start();
new WC(p1).start();
new WC(p2).start();
}
}使用Class作为线程对象锁
语法结构：synchronized ( XX . class ){// 同步代码}或：synchronized public static void accessVal ()
使用自定义对象作为线程对象锁
语法结构：synchronized ( 自定义对象 ){// 同步代码}
死锁及问题的解决
死锁的概念
“
死锁
”
指的是：
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能进行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。
死锁问题的解决
死锁是由于 “
同步块需要同时持有多个对象锁造成
”
的，要解决这个问题，思路很简单，就是：同一个代码块，不要同时持有两个对象锁
线程并发协作(生产者/消费者模式)
多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者
/
消费者模式
”
。
角色介绍
什么是生产者？
生产者指的是负责生产数据的模块（这里模块可能是：方法、对象、线程、进程）。
什么是消费者？
消费者指的是负责处理数据的模块（这里模块可能是：方法、对象、线程、进程）。
什么是缓冲区？
消费者不能直接使用生产者的数据，它们之间有个
“
缓冲区
”
。生产者将生产好的数据放入“
缓冲区
”
，消费者从
“
缓冲区
”
拿要处理的数据。
缓冲区是实现并发的核心，缓冲区的设置有两个好处：
1
实现线程的并发协作有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况；同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。 这样，就从逻辑上实现了“ 生产者线程 ” 和 “ 消费者线程 ” 的分离，解除了生产者与消费者之间的耦合。2解决忙闲不均，提高效率生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费；消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据。
实现生产者与消费者模式
创建缓冲区
/**
* 定义馒头类
*/
class ManTou{
private int id;
public ManTou(int id){
this.id = id;
}
public int getId(){
return this.id;
}
}
/**
* 定义缓冲区类
*/
class SyncStack{
//定义存放馒头的盒子
private ManTou[] mt = new ManTou[10];0 //定义操作盒子的索引
private int index;
/**
* 放馒头
*/
public synchronized void push(ManToumanTou){
//判断盒子是否已满
while(this.index == this.mt.length){
try {
/**
* 语法：wait(),该方法必须要在synchronized块中调用。
* wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
* 其他需要该对象锁的线程就可以继续运行了。
*/
this.wait();
} catch (InterruptedException e){
e.printStackTrace();
}
}
//唤醒取馒头的线程
/**
* 语法：该方法必须要在synchronized块中调用。
* 该方法会唤醒处于等待状态队列中的一个线程。
*/
this.notify();
this.mt[this.index] = manTou;
this.index++;
}
/**
* 取馒头
*/
public synchronized ManTou pop(){
while(this.index == 0){
try {
/**
* 语法：wait(),该方法必须要在synchronized块中调用。
* wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
* 其他需要该对象锁的线程就可以继续运行了。
*/
this.wait();
} catch (InterruptedException e){
e.printStackTrace();
}
}
this.notify();
this.index--;
return this.mt[this.index];
}
}
public class TestProduceThread {
public static void main(String[] args) {3
}
}创建生产者消费者线程
/**
* 定义馒头类
*/
class ManTou{
private int id;
public ManTou(int id){
this.id = id;
}
public int getId(){
return this.id;
}
}
/**
* 定义缓冲区类
*/
class SyncStack{
//定义存放馒头的盒子
private ManTou[] mt = new ManTou[10];
//定义操作盒子的索引
private int index;
/**
* 放馒头
*/
public synchronized void push(ManToumanTou){
//判断盒子是否已满
while(this.index == this.mt.length){
try {
/**
* 语法：wait(),该方法必须要在synchronized块中调用。
* wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
* 其他需要该对象锁的线程就可以继续运行了。 */
this.wait();
} catch (InterruptedExceptione) {
e.printStackTrace();
}
}
//唤醒取馒头的线程
/**
* 语法：该方法必须要在synchronized块中调用。
* 该方法会唤醒处于等待状态队列中的一个线程。
*/
this.notify();
this.mt[this.index] = manTou;
this.index++;
}
/**
* 取馒头
*/
public synchronized ManTou pop(){
while(this.index == 0){
try {
/**
* 语法：wait(),该方法必须要在synchronized块中调用。
* wait执行后，线程会将持有的对象锁释放，并进入阻塞状态，
* 其他需要该对象锁的线程就可以继续运行了。
*/
this.wait();
} catch (InterruptedExceptione) {
e.printStackTrace();
}
}
this.notify();
this.index--;
return this.mt[this.index];
}
}
/**
* 定义生产者线程类
*/
class ShengChan extends Thread{
private SyncStack ss;
public ShengChan(SyncStack ss){
this.ss = ss;
}
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println("生产馒头："+i);
ManTou manTou = new ManTou(i);
this.ss.push(manTou);
}
}
}
/**
* 定义消费者线程类
*/
class XiaoFei extends Thread{
private SyncStack ss;
public XiaoFei(SyncStack ss){
this.ss = ss;
}
@Override
public void run() {
for(int i=0;i<10;i++){
ManTou manTou = this.ss.pop();
System.out.println("消费馒头："+i);
}
}
}
public class ProduceThread {
public static void main(String[] args)
{
SyncStack ss = new SyncStack();
new ShengChan(ss).start();
new XiaoFei(ss).start();
}
}线程并发协作总结
线程并发协作（也叫线程通信） 生产者消费者模式：
1
生产者和消费者共享同一个资源，并且生产者和消费者之间相互 依赖，互为条件。
2
对于生产者，没有生产产品之前，消费者要进入等待状态。而生产了产品之后，又需要马上通知消费者消费。
对于消费者，在消费之后，要通知生产者已经消费结束，需要继续生产新产品以供消费。
4
在生产者消费者问题中，仅有synchronized
是不够的。synchronized可阻止并发更新同一个共享资源，实现了同步但是synchronized
不能用来实现不同线程之间的消息传递（通信）。
那线程是通过哪些方法来进行消息传递（通信）的呢？见如下总结：
以上方法均是java.lang.Object类的方法；都只能在同步方法或者同步代码块中使用，否则会抛出异常。
秃头建议：在实际开发中，尤其是“ 架构设计 ” 中，会大量使用这个模式。对于初学者了解即可，如果晋升到中高级开发人员，这就是必须掌握的内容。
只讲干货
#有什么错误的地方大家多多担待，欢迎大家留下意见共同努力。
#需要什么技术的内容大家也可以积极留言。
#有升本的伙伴也可留言，后序也可更新升本内容C 和数据结构。
#有需要的伙伴或有什么问题直接联留下wx或联系邮箱2821835676qq.com
534
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
