Thread笔记
一、 简单的多线程例子
class Ticket extends Thread
{
private int tickets = 100;
public void run() {
while(true) {
if(tickets > 0) {
System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
}
}
}
}
public class ThreadDemo_1
{
public static void main(String[] args)
{
Ticket t1 = new Ticket();
Ticket t2 = new Ticket();
Ticket t3 = new Ticket();
Ticket t4 = new Ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
上面的程序将会出现每个线程都卖出100张票的问题
而解决问题的方法有两种：
第一种：在tickets前面加上static使其成为静态的，private static int tickets = 100;
第二种：实现Runnable接口创建线程
class Ticket implements Runnable
{
private int tickets = 100;
public void run() {
while(true) {
if(tickets > 0) {
System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
}
}
}
}
public class ThreadDemo_3
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
使用实现接口的方式创建线程的好处很多，最重要的是它可以实现线程的同时，继承其它的类，实现多继承的效果。以后的程序中会以实现接口的方式为主。
二、 上面的程序虽然解决了问题，但还有隐藏的问题存在。例如，如果在判断语句if(tickets > 0)之后，加上sleep()方法则会出现有线程卖出票号为负的问题。原因在此不做解释，分析可得。
class Ticket implements Runnable
{
private int tickets = 100;
public void run() {
while(true) {
if(tickets > 0) {
try {
Thread.sleep(10);
}
catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
}
}
}
}
程序运行的结果(最后面)：
Thread-0...sales_0
Thread-3...sales_-1
Thread-1...sales_-2
三、 为解决上述问题，修改类如下：
class Ticket implements Runnable
{
private int tickets = 100;
Object object = new Object();
public void run() {
while(true) {
synchronized(object) {
if(tickets > 0) {
try {
Thread.sleep(10);
}
catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
}
}
}
}
}
锁定成员变量，使得在一段时间内只有一个线程能够访问到共用的成员变量。
第二种锁定方法：不能直接锁定run()方法，要不然只有第一个线程能够访问run方法，而且里面是无限循环，也就是说只有一个线程在卖票，而其余的线程没能起到相应的作用。
class Ticket implements Runnable
{
private int tickets = 100;
Object object = new Object();
public void run() {
while(true) {
show();
}
}
public synchronized void show() {
if(tickets > 0) {
try {
Thread.sleep(10);
}
catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...sales_" + tickets--);
}
}
}
四、 由上述程序我们可以看到，synchronized()方法的参数(即锁)是任一对象，那我们对方法进行锁定的时候，没有指明锁是哪个，那么默认的锁是哪个呢？默认的锁是this，下面我们使用程序进行验证。
class Ticket implements Runnable
{
private int tickets = 100;
Object obj = new Object();
boolean flat = true;
public void run() {
if(flat) {
while(true) {
synchronized(obj) {
if(tickets > 0) {
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "...sales..." + tickets--);
}
}
}
} else { show(); }
}
public synchronized void show() {
while(true) {
if(tickets > 0) {
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "...show_" + tickets--);
}
}
}
}
public class ThisLockDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{Thread.sleep(10);}catch (Exception e){}
t.flat = false;
t2.start();
}
}
使用两个线程进行售票，但将两个线程分开进行执行，当不使用默认锁的时候，我们可以得到的运行结果是：
Thread-1...show_3
Thread-0...sales...2
Thread-1...show_1
Thread-0...sales...0
可以看出其售出了0号票，可以我们已经加锁了，怎么会这样呢，因为使用的是两个不同的锁，所以会出现问题，如果我们将，非默认的锁改成this则会得到输出结果为：
Thread-1...show_4
Thread-1...show_3
Thread-1...show_2
Thread-1...show_1
没有出现0号票，使用的是同一个锁，所以证明，没有指定锁对象的时候，使用的是this对象。
五、 如果同步的方法是静态的，那么它使用的锁对象又是谁呢？由于静态方法中，是没有this对象的，而只有一个类的字节码文件对象，因此我们猜此时的锁对象就是它的字节码文件对象，下面我们使用程序进行验证：
将Ticket类修改如下，使show()方法变成静态方法：
class Ticket implements Runnable
{
private static int tickets = 100;
boolean flat = true;
public void run() {
if(flat) {
while(true) {
synchronized(this) {
if(tickets > 0) {
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "...sales..." + tickets--);
}
}
}
} else { show(); }
}
public static synchronized void show() {
while(true) {
if(tickets > 0) {
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "...show_" + tickets--);
}
}
}
}
则我们得到程序的运行结果：
Thread-1...show_3
Thread-0...sales...2
Thread-1...show_1
Thread-0...sales...0
又出现了0号票，因此静态方法的锁对象不是this对象。下面验证其锁对象为方法所在类的字节码文件对象，此时我们将this修改为Thicket.class进行实验，得到运行结果：
Thread-0...sales...4
Thread-0...sales...3
Thread-0...sales...2
Thread-0...sales...1
由此可以验证，静态方法使用的锁对象是方法所在类的字节码文件对象。
六、 死锁程序
class Test implements Runnable
{
//定义布尔变量flag，对线程进行判断，让其执行相应的代码块
private boolean flag;
public Test(boolean flag) {
this.flag = flag;
}
//使用两个锁对象，对两个代码块都进行锁定，而且是相互锁定
public void run() {
//根据线程的布尔属性执行不同的代码块
//两个锁对象是相互嵌套的
if(flag) {
synchronized(DeadLockTest.locka) {
System.out.println("if locka");
synchronized(DeadLockTest.lockb) {
System.out.println("if lockb");
}
}
} else {
synchronized(DeadLockTest.lockb) {
System.out.println("else lockb");
synchronized(DeadLockTest.locka) {
System.out.println("else locka");
}
}
}
}
}
public class DeadLockTest
{
static Object locka = new Object();
static Object lockb = new Object();
public static void main(String[] args)
{
//建立两个布尔属性不一样的线程，并启动
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}
/******************************对死锁的程序要理解透彻**************************************/
七、 加锁使线程同步时要注意的三个条件
第一、 多个线程
第二、 操作同一对象
第三、 使用同一个锁
八、 线程间的通讯(设置一个人的属性读一个人)
class People
{
private String name;
private String sex;
boolean flag = false;
public synchronized void set(String name, String sex) {
if(flag)
try{this.wait();}catch(InterruptedException e) {}
this.name = name;
this.sex = sex;
flag = true;
this.notify();
}
public synchronized void out() {
if(!flag)
try{this.wait();}catch(InterruptedException e) {}
System.out.println(name + "..." + sex);
flag = false;
this.notify();
}
}
class Input implements Runnable
{
private People p;
public Input(People p) {
this.p = p;
}
int i = 0;
public void run() {
while(true) {
if(i == 0) {
p.set("nike","male");
} else {
p.set("丽丽","女");
}
i = (i+1)%2;
}
}
}
class Output implements Runnable
{
private People p;
public Output(People p) {
this.p = p;
}
public void run() {
while(true) {
p.out();
}
}
}
public class InputOutputDemo_2
{
public static void main(String[] args)
{
People p = new People();
new Thread(new Input(p)).start();
new Thread(new Output(p)).start();
}
}
九、 当出现两个以上的生产者和消费者时，我们需要使用while进行判断，且使用notifyAll()唤醒所有线程
class Product
{
private String name = "";
private int count = 0;
boolean flag = false;
public synchronized void set(String name) {
while(flag) //*********
try{this.wait();}catch(InterruptedException e) {}
this.name = name + "..." + count++;
System.out.println(Thread.currentThread().getName() + "...生产者" + this.name);
flag = true;
this.notifyAll();
}
public synchronized void out() {
while(!flag)//********
try{this.wait();}catch(InterruptedException e) {}
System.out.println(Thread.currentThread().getName() + "...消费者......" + this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable
{
private Product pro;
public Producer(Product pro) {
this.pro = pro;
}
public void run() {
while(true) {
pro.set("商品");
}
}
}
class Consumer implements Runnable
{
private Product pro;
public Consumer(Product pro) {
this.pro = pro;
}
public void run() {
while(true) {
pro.out();
}
}
}
class ProducerConsumerTest
{
public static void main(String[] args)
{
Product pro = new Product();
Producer p = new Producer(pro);
Consumer c = new Consumer(pro);
Thread t1 = new Thread(p);
Thread t2 = new Thread(p);
Thread t3 = new Thread(c);
Thread t4 = new Thread(c);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
十、 线程间的通信、
JDK1.5的新特性：提供了多线程升级解决方案，将同步synchronized替换成现实Lock操作，将Object中的wait,notify,notifyAll等方法替换成Condition对象，该对象可以通过Lock锁进行获取，可以实现只唤醒对方的操作，不过解锁的动作必须要完成，也就是用finally包括。
分享到：
相关推荐
电子书相关：包含4个有关JAVA线程的电子书（几乎涵盖全部有关线程的书籍） OReilly.Java.Threads.3rd.Edition.Sep.2004.eBook-DDU Java Thread Programming (Sams) java线程第二版中英文 java线程第二版中英文 ...
Java线程状态流转图知识点总结 Java线程状态流转图是一种用于描述Java线程生命周期中不同的状态和状态转换的图形表示方式。该图形展示了Java线程从创建到终止的整个生命周期，并详细介绍了每种状态的特点和转换...
java 线程Dump 分析工具： Java的TDA线程转储分析器是一个用于分析Sun Java VM生成的线程转储和堆信息的小型Swing GUI(目前用1.4测试)。它从提供的日志文件中解析线程转储和类直方图。它提供关于发现的线程转储的...
根据提供的信息，我们可以推断出这份文档主要关注的是Java线程的相关内容。下面将围绕“Java线程”这一主题展开详细的介绍与解释。 ### Java线程基础 在Java语言中，线程是程序执行流的基本单元。一个标准的Java...
Java线程分析是Java开发中的重要环节，尤其是在处理性能优化、死锁排查或者并发问题时。TDA（Thread Dump Analyzer）是一款强大的Java线程分析工具，它能够帮助开发者深入理解应用在运行时的线程状态，包括线程的...
Java线程是并发编程的核心部分，它允许程序在同一时间执行多个独立的任务，从而提高系统效率和响应速度。本文将深入探讨Java线程的概念、生命周期、实现方式以及相关的同步机制。 首先，理解线程的基本概念至关重要...
Java线程是多任务编程的重要概念，它允许程序同时执行多个独立的任务，从而提高系统效率和响应速度。在Java中，线程可以分为用户线程和守护线程，前者是程序运行的基础，而后者是在所有用户线程结束时才终止的后台...
Java线程是Java编程语言中的一个核心概念，它允许程序同时执行多个任务，极大地提高了程序的并发性和效率。本教程将深入探讨Java线程的使用，帮助开发者掌握这一关键技术。 一、线程基础 1. **线程的概念**：线程...
Java线程是Java编程中的重要概念，特别是在多核处理器和并发处理中不可或缺。Java线程允许程序在同一时间执行多个不同的任务，从而提高了程序的效率和响应性。在燕山大学信息学院计算机系的课程中，李峰教授讲解了...
Java线程是Java编程语言中的核心概念，尤其在多任务处理和并发编程中扮演着重要角色。线程允许一个程序内部同时执行多个独立的控制流，使得程序能够更高效地利用处理器资源。本文将深入解析Java线程的相关知识点，...
《Java线程(第三版)》是一本深入探讨Java线程技术的专业书籍，旨在帮助开发者理解和掌握Java平台上的多线程编程。Java线程是并发编程的重要组成部分，它允许程序同时执行多个任务，从而充分利用系统资源，提高程序的...
### Java线程入门知识点详解 #### 一、Java线程基础知识概述 **1.1 什么是线程？** 线程是程序执行流的最小单元，是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。在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() { // 业务逻辑 ...
Java线程亲和性（Thread Affinity）是一个高级并发编程概念，主要涉及到操作系统调度和硬件资源的优化。在多核处理器系统中，线程亲和性允许开发者指定某个线程应该运行在哪个特定的处理器核心上，从而提高性能、...
java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具类 java 线程工具类java 线程工具...
4种常用Java线程锁的特点，性能比较、使用场景 线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发...
本资源"JAVA线程学习(源代码)"提供了关于Java线程的源代码示例，帮助我们深入理解和实践线程的使用。 首先，我们要理解Java中的线程模型。Java线程由`java.lang.Thread`类或`java.util.concurrent.Executor`框架来...
Java 线程状态转换图 Java 线程状态转换图是 Java 编程中非常重要的一个概念，它描述了线程在不同的状态之间的转换关系。了解线程状态转换图对 Java 编程的理解和应用非常重要。本文将详细介绍 Java 线程状态转换图...