JAVA多线程
多线程的基本概念
线程指进程中的一个执行场景，也就是执行流程，那么进程和线程有什么区别呢？
- 每个进程是一个应用程序，都有独立的内存空间
- 同一个进程中的线程共享其进程中的内存和资源（共享的内存是堆内存和方法区内存，栈内存不共享，每个线程有自己的。）
什么是进程？
一个进程对应一个应用程序。例如：在 windows 操作系统启动 Word 就表示启动了一个
进程。在 java 的开发环境下启动 JVM，就表示启动了一个进程。现代的计算机都是支持多
进程的，在同一个操作系统中，可以同时启动多个进程。
多进程有什么作用？
单进程计算机只能做一件事情。
玩电脑，一边玩游戏（游戏进程）一边听音乐（音乐进程）。
对于单核计算机来讲，在同一个时间点上，游戏进程和音乐进程是同时在运行吗？不是。
因为计算机的 CPU 只能在某个时间点上做一件事。由于计算机将在“游戏进程”和“音乐
进程”之间频繁的切换执行，切换速度极高，人类感觉游戏和音乐在同时进行。
多进程的作用不是提高执行速度，而是提高 CPU 的使用率。
进程和进程之间的内存是独立的。
什么是线程？
线程是一个进程中的执行场景。一个进程可以启动多个线程。
多线程有什么作用？
多线程不是为了提高执行速度，而是提高应用程序的使用率。
线程和线程共享“堆内存和方法区内存”，栈内存是独立的，一个线程一个栈。
可以给现实世界中的人类一种错觉：感觉多个线程在同时并发执行。
java 程序的运行原理？
java 命令会启动 java 虚拟机，启动 JVM，等于启动了一个应用程序，表示启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的 main 方法。所以 main方法运行在主线程中。在此之前的所有程序都是单线程的。
线程生命周期
线程是一个进程中的执行场景,一个进程可以启动多个线程
新建：采用 new 语句创建完成
就绪：执行 start 后
运行：占用 CPU 时间
阻塞：执行了 wait 语句、执行了 sleep 语句和等待某个对象锁，等待输入的场合
终止：退出 run()方法
多线程不是为了提高执行速度,而是提高应用程序的使用率.
线程和线程共享”堆内存和方法区内存”.栈内存是独立的,一个线程一个栈.
可以给现实世界中的人类一种错觉 : 感觉多线程在同时并发执行.
很多人都对其中的一些概念不够明确，如同步、并发等等，让我们先建立一个数据字典，以免产生误会。
- 多线程：指的是这个程序（一个进程）运行时产生了不止一个线程
- 并行与并发：
·
- 并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
·
- 并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。
线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果，如不加事务的转账代码：
void transferMoney(User from, User to, float amount) {
to.setMoney(to.getBalance() + amount);
from.setMoney(from.getBalance() - amount);
}
同步：Java中的同步指的是通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时，提高性能，才是优秀的程序。线程安全的优先级高于性能。
Java命令会启动Java虚拟机,启动JVM,等于启动了一个应用程序,表示启动了一个进程,该进程会自动启动一个”主线程”,
然后主线程去调用某个类的main()方法,所以main()方法运行在主线程中.
线程的调度与控制
线程的调度模型分为: 分时调度模型和抢占式调度模型,Java使用抢占式调度模型
通常我们的计算机只有一个 CPU，CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，才可以执行指令。在单 CPU 的机器上线程不是并行运行的，只有在多个 CPU 上线程才可以并行运行。Java 虚拟机要负责线程的调度，取得 CPU 的使用权，目前有两种调度模型：分时调度模型和抢占式调度模型，Java 使用抢占式调度模型。分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些。
l 分时调度模型: 所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片
l 抢占式调度模型: 优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的CPU时间片相对多一些.
public class ThreadTest {
public static void main(String[] args) {
ThreadTest1();
// ThreadTest2();
// ThreadTest3();
// ThreadTest4();
// ThreadTest5();
}
/**
* 三个方法: 获取当前线程对象:Thread.currentThread(); 给线程起名: t1.setName("t1"); 获取线程的名字:
* t.getName();
*/
private static void ThreadTest1() {
Thread t = Thread.currentThread();// t保存的内存地址指向的线程为"主线程"
System.out.println(t.getId());
Thread t1 = new Thread(new Processor1());
// 给线程起名
t1.setName("t1");
t1.start();
Thread t2 = new Thread(new Processor1());
t2.setName("t2");
t2.start();
}
/**
* 线程优先级高的获取的CPU时间片相对多一些 优先级: 1-10 最低: 1 最高: 10 默认: 5
*/
private static void ThreadTest2() {
Thread t1 = new Processor2();
Thread t2 = new Processor2();
t1.setName("t1");
t2.setName("t2");
System.out.println(t1.getPriority());
System.out.println(t2.getPriority());
t1.setPriority(1);
t2.setPriority(10);
t1.start();
t2.start();
}
/**
* 1.Thread.sleep(毫秒); 2.sleep方法是一个静态方法 3.该方法的作用: 阻塞当前线程,腾出CPU,让给其它线程
*/
private static void ThreadTest3() {
Thread t = new Thread(new Processor3());
t.start();
for (int i = 0; i < 11; i++) {
System.out.println(Thread.currentThread().getName() + "========>"
+ i);
try {
t.sleep(5000);// 等同于Thread.sleep(5000);阻塞的还是当前线程,和t线程无关.
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 某线程正在休眠,如何打断它的休眠 以下方式依靠的是异常处理机制
*/
private static void ThreadTest4() {
try {
Thread t = new Thread(new Processor4());
t.start();
Thread.sleep(5000);// 睡5s
t.interrupt();// 打断Thread的睡眠
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 如何正确的更好的终止一个正在执行的线程 需求:线程启动5s之后终止.
*/
private static void ThreadTest5() {
Processor5 p = new Processor5();
Thread t = new Thread(p);
t.start();
// 5s之后终止
try {
Thread.sleep(5000);
p.isRun = false;
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class Processor1 implements Runnable {
@Override
public void run() {
Thread t = Thread.currentThread();// t保存的内存地址指向的线程为"t1线程对象"
System.out.println(t.getName());
System.out.println(t.getId());
}
}
class Processor2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName()
+ "----------->" + i);
}
}
}
class Processor3 implements Runnable {
/**
* Thread中的run方法不能抛出异常,所以重写runn方法之后,在run方法的声明位置上不能使用throws
* 所以run方法中的异常只能try...catch...
*/
@Override
public void run() {
for (int i = 0; i < 11; i++) {
System.out.println(Thread.currentThread().getName() + "========>"
+ i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Processor4 implements Runnable {
@Override
public void run() {
try {
Thread.sleep(1000000000);
System.out.println("能否执行这里");
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 11; i++) {
System.out.println(Thread.currentThread().getName() + "========>"
+ i);
}
}
}
class Processor5 implements Runnable {
boolean isRun = true;
@Override
public void run() {
for (int i = 0; i < 11; i++) {
if (isRun) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "========>" + i);
}
}
}
}
线程优先级
线 程 优 先 级 主 要 分 三 种 ： MAX_PRIORITY( 最 高 );MIN_PRIORITY （ 最 低 级 ）NORM_PRIORITY(标准)默认
//设置线程的优先级，线程启动后不能再次设置优先级
//必须在启动前设置优先级
//设置最高优先级
t1.setPriority(Thread.MAX_PRIORITY);
sleep
public class SleepTest {
public static void main(String[] args) {
System.out.println("Wait");
// 让主线程等待5秒再执行
Wait.bySec(5);
// 提示恢复执行
System.out.println("start");
}
}
class Wait {
public static void bySec(long s) {
// sleep s个1秒
for (int i = 0; i < s; i++) {
System.out.println(i + 1 + "秒");
try {
// sleep1秒
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
停止一个线程
l 如果我们的线程正在睡眠，可以采用 interrupt 进行中断
l 通常定义一个标记，来判断标记的状态停止线程的执行
yield
它与 sleep()类似，只是不能由用户指定暂停多长时间，并且 yield()方法只能让同优先级的线程有执行的机会,采用 yieid 可以将 CPU 的使用权让给同一个优先级的线程
public class YieldTest {
public static void main(String[] args) {
FirstThread mt = new FirstThread();
SecThread mnt = new SecThread();
mt.start();
mnt.start();
}
}
class FirstThread extends Thread{
public void run(){
for(int i=0;i<5;i++){
System.out.println("第一个线程的第 "+(i+1)+"次运行");
Thread.yield(); //暂停线程
}
}
}
class SecThread extends Thread{
public void run(){
for(int i=0;i<5;i++){
System.out.println("第二个线程的第 "+(i+1)+"次运行");
Thread.yield();
}
}
}
join
当前线程可以调用另一个线程的 join 方法，调用后当前线程会被阻塞不再执行，直到被调用的线程执行完毕，当前线程才会执行
public class JoinTest extends Thread {
public JoinTest(String name) {
super(name);
}
public void run() {
for (int i = 0; i < 5; i++)
System.out.println(getName() + "" + i);
}
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i == 5) {
JoinTest tempjt = new JoinTest("半路加入的线程");
try {
tempjt.start();
tempjt.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+""+i);
}
}
}
synchronized
线程同步，指某一个时刻，指允许一个线程来访问共享资源，线程同步其实是对对象加锁，如果对象中的方法都是同步方法，那么某一时刻只能执行一个方法，采用线程同步解决以上的问题，我们只要保证线程一操作 s 时，线程 2 不允许操作即可，只有线程一使用完成 s 后，再让线程二来使用 s 变量
· 异步编程模型 : t1线程执行t1的,t2线程执行t2的,两个线程之间谁也不等谁.
· 同步编程模型 : t1线程和t2线程执行,t2线程必须等t1线程执行结束之后,t2线程才能执行,这是同步编程模型.
·
· 什么时候要用同步呢?为什么要引入线程同步呢?
· 1.为了数据的安全,尽管应用程序的使用率降低,但是为了保证数据是安全的,必须加入线程同步机制.
· 线程同步机制使程序变成了(等同)单线程.
· 2.什么条件下要使用线程同步?
· 第一: 必须是多线程环境
· 第二: 多线程环境共享同一个数据.
· 第三: 共享的数据涉及到修改操作.
// synchronized 是对对象加锁
// 采用 synchronized 同步最好只同步有线程安全的代码
// 可以优先考虑使用 synchronized 同步块
// 因为同步的代码越多，执行的时间就会越长，其他线程等待的时间就会越长
// 影响效率
public class TestWithdrawal {
public static void main(String[] args) {
// 创建两个线程
TestAccount r = new TestAccount();
Thread one = new Thread(r);
Thread two = new Thread(r);
one.setName("张三");
two.setName("张三的妻子");
// 启动线程
one.start();
two.start();
}
}
class Account {
private int balance = 500; // 余额
public int getBalance() {
return balance;
}
// 取款
public void withdraw(int amount) {
balance = balance - amount;
}
}
class TestAccount implements Runnable {
// 所有用TestAccount对象创建的线程共享同一个帐户对象
private Account acct = new Account();
public void run() {
for (int i = 0; i < 5; i++) {
makeWithdrawal(100);// 取款
if (acct.getBalance() < 0) {
System.out.println("账户透支了!");
}
}
}
private void makeWithdrawal(int amt) {
synchronized (acct) {
if (acct.getBalance() >= amt) {
System.out.println(Thread.currentThread().getName() + " 准备取款");
try {
Thread.sleep(500);// 0.5秒后实现取款
} catch (InterruptedException ex) {
}
// 如果余额足够，则取款
acct.withdraw(amt);
System.out.println(Thread.currentThread().getName() + " 完成取款,余额："+acct.getBalance());
} else {
// 余额不足给出提示
System.out.println("余额不足以支付 "
+ Thread.currentThread().getName() + " 的取款，余额为 "
+ acct.getBalance());
}
}
}
}
死锁
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new Thread(new T1(o1, o2));
Thread t2 = new Thread(new T2(o1, o2));
t1.start();
t2.start();
}
}
class T1 implements Runnable {
Object o1;
Object o2;
T1(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2) {
}
}
}
}
class T2 implements Runnable {
Object o1;
Object o2;
T2(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
@Override
public void run() {
synchronized (o2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1) {
}
}
}
}
守护线程
从线程分类上可以分为：用户线程（以上讲的都是用户线程），另一个是守护线程。守护线程是这样的，所有的用户线程结束生命周期，守护线程才会结束生命周期，只要有一个用户线程存在，那么守护线程就不会结束，例如 java 中著名的垃圾回收器就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。
· 其它所有的用户线程结束,则守护线程退出!
· 守护线程一般都是无限执行的.
public class DaemonThread {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable2());
t1.setName("t1");
// 将t1这个用户线程修改成守护线程.在线程没有启动时可以修改以下参数
t1.setDaemon(true);
t1.start();
// 主线程
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "----->" + i);
Thread.sleep(1000);
}
}
}
class Runnable2 implements Runnable {
@Override
public void run() {
int i = 0;
while (true) {
i++;
System.out.println(Thread.currentThread().getName() + "-------->"
+ i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
设置为守护线程后，当主线程结束后，守护线程并没有把所有的数据输出完就结束了，也即是说守护线程是为用户线程服务的，当用户线程全部结束，守护线程会自动结束
Timer.schedule()
/**
* 关于定时器的应用 作用: 每隔一段固定的时间执行一段代码
*/
public class TimerTest {
public static void main(String[] args) throws ParseException {
// 1.创建定时器
Timer t = new Timer();
// 2.指定定时任务
t.schedule(new LogTimerTask(), new SimpleDateFormat(
"yyyy-MM-dd HH:mm:ss SSS").parse("2017-06-29 14:24:00 000"),
10 * 1000);
}
}
// 指定任务
class LogTimerTask extends TimerTask {
@Override
public void run() {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS")
.format(new Date()));
}
}
我是melon，一个10年编程老司机。Q我3474203856。 给melon留言或者说明是看到文章过来的。所有相关技术问题都可以一起寻找到答案。
原文地址：http://blog.51cto.com/13884944/2155589