JAVA 多线程（一）
进程和线程
进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该执行顺序是一个执行路径，或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元。
线程在控制着进程的执行。
在计算机中多个线程都获取cpu的执行权，cpu执行到谁，谁就运行，明确一点，在某一个时刻，只能由一个程序运行（多核除外），cpu做着快速切换，以达到看上去是同事运行的效果。我们可以形象的把多线程的运行行为在互相抢夺cpu的执行权，这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长时间，cpu说了算。
多线程的优势
l 多线程可以使得软件运行的速度更快，譬如迅雷可以多个线程同时下载一个文件，加快了下载的速度
l 进程之间不能共享内存，而线程之间则可以
如何创建启动线程：
方法一：
1、定义类继承Thread
2、复写Thread类中的run方法，目的是将自定义的代码存储在run方法中让线程运行
3、调用线程的start方法（ 该方法有两个作用：1.启动线程；2.调用run方法）
public class ThreadDemo extends Thread {
public static void main(String[] args) {
Thread thread1 = new Thread();
Thread thread2 = new Thread();
thread1.start();
thread2.start();
}
}
class ThreadTest extends Thread {
@Override
public void run() {
/**
* 这里是要实现多线程的代码
*/
}
}
方法二：
1、定义类实现Runnable接口
2、覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中
3、通过Thread类建立线程对象
4、将Running接口的子类对象作为实际参数传递给Thread类的构造函数。
5、调用Thread类的 start方法开启线程并调用Runnable接口子类的run方法
public class ThreadDemo extends Thread {
public static void main(String[] args) {
ThreadTest tt = new ThreadTest();
Thread thread1 = new Thread(tt);
Thread thread2 = new Thread(tt);
thread1.start();
thread2.start();
}
}
class ThreadTest implements Runnable {
@Override
public void run() {
/**
* 这里是要实现多线程的代码
*/
}
}
为什么要将Runnable接口的子类对象传递给Thread的构造函数？
因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定指定对象的run方法
为什么要覆盖run方法？
Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法，也就是说Thread类中的run方法，用于存储线程要运行的代码。
这两种实现方式的区别？
1、实现Runnable接口避免了单继承的局限性，在定义线程时建议使用实现Runnable方式，在实现了多线程之后还可以继承其他类
2、继承Thread类的线程代码存放在Thread子类的run方法中，实现Runnable线程代码存放在接口的子类的run方法中。
线程的状态
新建和就绪
当使用new关键字新建了一个线程之后，该线程就属于新建状态，这个时候的它和其他Java对象一样，仅仅由JAVA虚拟机为它分配内存，并初始化它的值
调用start()方法之后，该线程属于就绪状态，表示该线程可以运行了，但是何时运行得看JVM的内部调度。
运行和阻塞
当线程取得执行权限，run方法内的线程体开始执行时，该线程出于运行状态
sleep(time)方法可以让线程冻结time长度的时间，time之后，继续执行线程
wait()方法也可以冻结线程，冻结之后，需要notify()方法唤醒线程，否则会一直冻结
线程死亡
run方法内部代码执行完毕或者遇到异常或error时候，线程结束，线程进入死亡状态
stop()方法可以直接杀掉线程，但容易导致死锁，通常不推荐
临时状态（阻塞状态）
当同时运行多个线程时候，而cpu只能运行一个线程，那么其他线程就会先进入临时状态（阻塞状态）
典型例子
火车站卖票就是一个典型的多线程的例子，票的总量是固定的，但是会有多个窗口在卖票，假设一共有100张票，一共有6个窗口在售票，当有人来买票的时候，窗口售票员先看是否有余票，如果有，则出售。
//使用实现Runnable接口方式实现
public class SellTicket {
public static void main(String[] args) {
TicketThread tt = new TicketThread(); Thread t1 = new Thread(tt);
Thread t2 = new Thread(tt); t1.start();
t2.start();
}
} class TicketThread implements Runnable { public int ticketCount = 100; @Override
public void run() {
while (true) {
sellTicket();
if (ticketCount == 0) {
break;
}
}
} public void sellTicket() {
if (ticketCount > 0) {
System.out.println(Thread.currentThread().getName() + " 卖了第 "
+ ticketCount-- + " 张票"); try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
} //使用继承Thread类实现
public class SellTicket {
public static void main(String[] args) { TicketThread tt1 = new TicketThread();
TicketThread tt2 = new TicketThread(); tt1.start();
tt2.start();
}
} class TicketThread extends Thread { public static int ticketCount = 100; @Override
public void run() {
while (true) {
sellTicket();
if (ticketCount == 0) {
break;
}
}
} public void sellTicket() {
if (ticketCount > 0) {
System.out.println(Thread.currentThread().getName() + " 卖了第 "
+ ticketCount-- + " 张票"); try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
多执行几次的话，就会发现，会发生一票多卖的情况，是因为线程获取到CPU的执行权限之后做运算，还没有将票数减少，另外一个线程抢夺到了CPU的执行权限，所以他们卖出的是同一张票，这个时候就出现了问题，为了解决这个问题，JAVA的多线程支持引入了同步监视器来解决这个问题
线程同步
JAVA使用synchronized关键字在线程开始执行同步代码快之前，获取对同步监视器的锁定
synchronized代码块
public void run() {
method();
}
public void method () {
synchronized (this){
同步代码段
}
}
注意，普通方法中的同步对象是this，静态方法中的同步对象是 类名.class
public class SellTicket {
public static void main(String[] args) {
TicketThread tt = new TicketThread();
Thread t1 = new Thread(tt);
Thread t2 = new Thread(tt);
t1.start();
t2.start();
}
}
class TicketThread implements Runnable {
public int ticketCount = 100;
@Override
public void run() {
while (true) {
synchronized (this) {
sellTicket();
if (ticketCount == 0) {
break;
}
}
}
}
public void sellTicket() {
if (ticketCount > 0) {
System.out.println(Thread.currentThread().getName() + " 卖了第 "
+ ticketCount-- + " 张票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
synchronized方法
public void run() {
method();
}
public synchronized void method () {
同步代码段
}
package cn.lixyz.thread;
public class SellTicket {
public static void main(String[] args) {
TicketThread tt = new TicketThread();
Thread t1 = new Thread(tt);
Thread t2 = new Thread(tt);
t1.start();
t2.start();
}
}
class TicketThread implements Runnable {
public int ticketCount = 100;
@Override
public void run() {
while (true) {
sellTicket();
if (ticketCount == 0) {
break;
}
}
}
public synchronized void sellTicket() {
if (ticketCount > 0) {
System.out.println(Thread.currentThread().getName() + " 卖了第 "
+ ticketCount-- + " 张票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
使用synchronized修饰的代码就好比拥有了一把锁，当线程对象开始执行同步内容代码时，其他线程即时获取了CPU的执行权限也无法执行，直到当前执行对象执行完毕释放权限。
最新文章
- [c#基础]关于try...catch最常见的笔试题
- 软件工程（FZU2015）赛季得分榜，第11回合(beta冲刺+SE总结)
- start WampServer如何关闭浏览目录
- Unity代码设置shader属性
- HeapSort自己yy-未完成
- HTML5基础
- 备份U盘分区表，未雨绸缪
- Singleton模式
- CentOS 6.4 离线安装 Cloudera 5.7.1 CDH 5.7.1
- Win Mingw-64获取
- componentsJoinedByString 和 componentsSeparatedByString 的方法的区别
- A Tour of Go Slicing slices
- 使用python发送简单的邮件
- 大并发大数量中的MYSQL瓶颈与NOSQL介绍
- Docker系列一：Docker基本概念及指令介绍
- VC调用静态库、动态库
- 记一次Nginx+Keepalived高可用故障转移
- 一道很有意思的java线程题
- Confluence 6 CSS 编辑技巧
- constructor&object 的对比