程序（program）
是为了完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象
进程（process）
是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生，存在和消亡的过程
如运行中的qq，mp3播放器
程序是静态的，进程是动态的
线程（thread）
进程可进一步细化为线程，是一个程序内部的一条执行路径。
若一个程序可同时执行多个线程，就是支持多线程的
何时需要多线程
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时，如用户输入，文件读写操作。网络操作，搜索等
- 需要一些后台进行的程序时
Thread
第一种方法（继承）
- 继承Java.lang.Thread
- 重写Thread的run()方法，方法内实现子线程要完成的功能
- 创建一个子类的对象
- 调用线程的start()方法。启动此线程；调用相应的run()方法
- Thread里的静态方法currentThread().getName()：得到线程的名字
- 线程只能被执行一次start()，
- 不能通过实现类对象的run()方法去启动一个线程，就没启动新线程
常用方法
- start：启动线程，调用run方法
- run：子线程要执行的代码就放在这
- currentThread：Thread的静态方法，调取当前进程
- getName：获取线程的名字
- setName：设置此线程的名字
- yield：调用此方法的进程释放当前cpu的执行权
- join：在A线程中调用B线程的join方法，表示，当执行到此方法，A线程暂停，直至B线程执行完毕，A线程再接着执行
- isAlive：判断当前进程是否还存活，返回boolean
- sleep(long time)：显式的让当前线程睡眠time，单位是毫秒
10.stop：方法已过时，停止进程 - 线程通信：wait，notify，notifyAll，在Object里
- 设置线程的优先级：
- 线程的调度：
时间片：按时间来
抢占式：高优先级的线程抢占CPU - Java的调度方法
同优先级线程的组成先进先出的队列（先到先服务），使用时间片策略
对高优先级，使用优先调度的抢占式策略 - 线程的优先级控制：
MAX_PRIORITY(10)
MIN_PRIORITY(1)
NORM_PRIORTY(5)：默认优先级
涉及的方法：
getPriority：获得线程的优先级值
setPriority(int newPriority)：设置新的优先级
只是抢到cpu的概率变大了，并不是一定抢到
- 继承实现多线程
class SubThread extends Thread {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "：" + i);
}
}
}
public class TestThread {
public static void main(String[] args) {
Thread s1 = new SubThread();
s1.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "：" + i);
}
}
}
第二种方法（实现接口）
static修饰的属性被类的实例所共有！
- 通过实现Runnable接口，然后用想要实现的代码放在run方法里
- 要先启动一个多线程，必须调用start方法
- 创建一个实现Runnable接口实现类的对象，并将其传入Thread的构造方法
Thread t1 = new Thread(new Test implements Runnable);- public Thread(Runner target)
- start()调用的是target的run方法，也就是构造器里的形参
- 实现接口来实现多线程
class Window1 implements Runnable {
int ticket = 100;
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出：" + ticket--);
} else {
break;
}
}
}
}
public class TestWindowImplements {
public static void main(String[] args) {
Runnable ra = new Window1();
Thread w1 = new Thread(ra);
Thread w2 = new Thread(ra);
Thread w3 = new Thread(ra);
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");//修改线程的名字
w1.setPriority(10);//设定线程的优先级，使其有更高的概率抢到CPU的执行权
w1.start();
w2.start();
w3.start();
}
}
两种方法
- 联系：Thread实现了Runnable
- 实现Runnable的方法更加方便
实现的方式避免Java里单继承的缺点
如果多个线程要操作同一份资源（或数据），更适合实现的方式
多线程的好处
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统cpu的利用率
- 改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
线程的分类
Java里的线程分为两类：一种是守护线程，一种是用户线程
- 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
- 守护线程是用来服务用户线程的，通过在start()方法前调用
thread.setDaemon(true)可以把一个用户线程变成一个守护线程。 - Java垃圾回收就是一个典型的守护线程
- 若JVM中都是守护线程，当前JVM将退出
线程的生命周期
- 新建：
- 就绪：
- 阻塞：
- 运行：
- 死亡：
线程的同步机制
- 线程安全问题存在的原因？
由于一个线程在操作共享数据的过程中，未执行完毕的情况下，另外的线程参与进来，导致共享数据存在了安全问题 - 如何解决线程的安全问题？
次必须让一个线程操作共享数据完毕以后，其它线程才能有机会参与共享数据的操作 - Java如何实现线程的安全：线程的同步机制
方法一：同步代码块
方法二：同步方法
同步代码块
synchronized(对象（同步监视器）){//对象在有的时候可以写this
//需要被同步的代码（即为操作共享数据的代码）
}
- 共享数据：多个线程共同操作的同一个数据（变量）
- 同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称，锁！
- 要求所有的线程必须用同一把锁
- 同步监器在一个进程访问共享数据时，会禁止其他进程访问。
- 注：在实现的方式中可以使用this来充当锁，若是继承的方式，就要慎用
class Window2 implements Runnable {
int ticket = 100;
public void run() {
while (true) {
synchronized (this) {//括号里填锁对象，任何类都可以，但在当前情况下必须要保证所有线程都是同一把锁
if (ticket > 0) {
try {
Thread.currentThread().sleep(10);//睡眠10毫秒，可以使线程的不安全性大大的展示出来！
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "售出：" + ticket--);
} else {
break;
}
}
}
}
}
public class TestWindowImplements_code_block {
public static void main(String[] args) {
Runnable ra = new Window1();
Thread w1 = new Thread(ra);
Thread w2 = new Thread(ra);
Thread w3 = new Thread(ra);
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");// 修改线程的名字
w1.setPriority(10);// 设定线程的优先级，使其有更高的概率抢到CPU的执行权
w1.start();
w2.start();
w3.start();
}
}
同步方法
public synchronized void show()：同步方法，能够保证当其中一个线程执行此方法时，其它线程在外等待直至此线程执行完成
- 同步方法的锁：this
- 同步代码块可以显式的指定锁，同步方法默认就为调用自己的对象
- 最好在实现方法的线程中使用
- 案列：三个售票窗口售一百张票
class Window3 implements Runnable {
int ticket = 100;
public void run() {
while(true) {
show();
if(ticket == 0) {
break;
}
}
}
private synchronized void show() {
// while(true) {//while(true)写在这里会引发窗口一把所有数据都打印的结果
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售出：" + ticket--);
} else {
return;
}
// }
}
}
public class TestWindowImplements_code_method {
public static void main(String[] args) {
Runnable ra = new Window3();
Thread w1 = new Thread(ra);
Thread w2 = new Thread(ra);
Thread w3 = new Thread(ra);
w1.setName("窗口一");
w2.setName("窗口二");
w3.setName("窗口三");// 修改线程的名字
// w1.setPriority(10);// 设定线程的优先级，使其有更高的概率抢到CPU的执行权
w1.start();
w2.start();
w3.start();
}
}
互斥锁—单例之懒汉式的线程安全
- 关于懒汉式的线程安全问题：使用同步机制
- 对于一般的方法内，使用同步代码块。可以考虑使用this
- 对于静态方法而言，使用当前类本身充当锁
- 线程的同步弊端：由于同一时间只能有一个线程访问共享数据，效率变低了
此代码线程不安全
class Singleton {
private Singleton() {
}
private static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
此代码线程安全
class Singleton {
private Singleton() {
}
private static Singleton instance = null;
public static Singleton getInstance() {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
return instance;
}
}
改进的版本
class Singleton {
private Singleton() {
}
private static Singleton instance = null;
public static Singleton getInstance() {
if(instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
释放锁的操作
- 当前线程的同步方法，同步代码块执行结束
- 当前线程在同步代码块，同步方法中遇到break，return终止了代码，该方法的继续执行
- 当前线程在同步代码块，同步方法中出现了未处理的Error或Exception，导致异常结束
- 当前线程在同步代码块，同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁
不会释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()，Thread.yield()方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）
- 应尽量避免使用suspend()和resume()来控制线程
- 实例，银行甲乙向账户各打三次钱
/**
* 1.是否涉及多线程？是，有两个用户（两种方法创建多线程） 2.是否有共享数据？有，同一账户 3.得考虑线程得同步。（两种方法处理线程的安全）
*
* @author Lenovo
*
*/
class Account {
double balance;
public Account() {
}
public synchronized void deposit(double amt) {
balance += amt;
System.out.println(Thread.currentThread().getName() + "：余额：" + balance);
}
}
class Customer extends Thread {
Account account;
public Customer(Account account) {
this.account = account;
}
public void run() {
for (int i = 0; i < 3; i++) {
account.deposit(1000);
}
}
}
public class TestAccount {
public static void main(String[] args) {
Account account = new Account();
Customer c1 = new Customer(account);
Customer c2 = new Customer(account);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
死锁的问题
不同的线程分别暂用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成线程的死锁
解决方法：专门的算法，原则；尽量减少同步资源的定义
- 案列：死锁
package demo;
public class TestDeadLock {
static StringBuffer sb1 = new StringBuffer();
static StringBuffer sb2 = new StringBuffer();
public static void main(String[] args) {
new Thread() {
public void run() {
synchronized (sb1) {
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
sb1.append("A");
synchronized (sb2) {
sb2.append("B");
}
}
System.out.println(sb1);
System.out.println(sb2);
}
}.start();
new Thread() {
public void run() {
synchronized (sb2) {
sb1.append("C");
synchronized (sb1) {
sb2.append("D");
}
System.out.println(sb1);
System.out.println(sb2);
}
}
}.start();
}
}
线程的通信
- wait
会使当前线程挂起并放弃CPU，同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问 - notify
唤醒正在排队等待的同步资源的线程中优先级最高者结束等待 - notifyAll
唤醒正在排队等待资源的所有线程结束等待
- Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报Java.lang.IllegalMonitorStateException异常
- 案列，使用两个线程打印1-100，线程一和线程二交替打印
class PrintNum implements Runnable {
int num = 1;
@Override
public void run() {
while (true) {
synchronized (this) {
if (num <= 100) {
notify();
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：" + num);
num++;
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
public class TestCommunication {
public static void main(String[] args) {
PrintNum p = new PrintNum();
Thread t1 = new Thread(p);
Thread t2 = new Thread(p);
t1.setName("甲");
t2.setName("乙");
t1.start();
t2.start();
}
}
- 案列，甲乙交互打钱
/**
* 1.是否涉及多线程？是，有两个用户（两种方法创建多线程） 2.是否有共享数据？有，同一账户 3.得考虑线程得同步。（两种方法处理线程的安全）
*
* @author Lenovo
*
*/
class Account {
double balance;
public Account() {
}
public synchronized void deposit(double amt) {
notify();
balance += amt;
System.out.println(Thread.currentThread().getName() + "：余额：" + balance);
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Customer extends Thread {
Account account;
public Customer(Account account) {
this.account = account;
}
public void run() {
for (int i = 0; i < 10; i++) {
account.deposit(1000);
}
}
}
public class TestAccount {
public static void main(String[] args) {
Account account = new Account();
Customer c1 = new Customer(account);
Customer c2 = new Customer(account);
c1.setName("甲");
c2.setName("乙");
c1.start();
c2.start();
}
}
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
