1. 创建多线程
进程: 正在执行的程序作为一个进程,进程负责内存空间的划分单核的CPU在一个时间只能执行一个应用程序,各个应用程序在抢CPU资源
* 线程 Thread : 任何一个java程序,jvm在运行的时候都会创建一个main线程执行main方法中所有的代码
* 一个java 应用程序至少有 2 个线程 jvm 创建的 一个 主线程 是负责 main 方法代码的执行,一个是垃圾回收器线程
* 创建新执行线程方法一:
1. 将类声明为 Thread 的子类。
2. 该子类应重写 Thread 类的 run 方法。? 目的: 自定义线程的任务代码就写在run方法中,自定义线程负责了 run 方法
3. 接下来可以分配并启动该子类的实例,创建Tread子类对象,并且调用 start 方法开启线程
* 一个线程一旦开启,那么线程会执行 run 方法中的代码, run 方法千万不能直接调用,直接调用run方法 就相当于调用一个普通方法而已,并没有开启新线程
public class test_1 extends Thread { // 继承 Thread 类
@Override
public void run() {
for(int i=0; i<5; i++) {
System.out.println("自定义线程: " + i);
}
}
public static void main(String args[]) {
test_1 test = new test_1();
// test.run(); // 直接调用run方法 就相当于调用一个普通方法而已,并没有开启新线程
test.start();
for(int i=0; i<3; i++) {
System.out.println("main线程: " + i);
}
}
}
******************** output *****************************
main线程: 0
自定义线程: 0
main线程: 1
自定义线程: 1
main线程: 2
自定义线程: 2
* 创建新执行线程方法二:
* 1. 自定义一个类实现runnable接口
* 2. 实现runnable接口的run方法,把自定义线程的任务定义在run方法上
* 3. 创建runnable 实现类对象
* 4. 创建 Thread 类的对象,并且把Runnable实现类的对象作为实参传递。
* 5. 调用Thread 对象的start 方法开启一个线程。
* 问题一: Runnable实现类的对象是线程对象吗?
* 不是, 只是实现了Runnable 接口的对象而已。 只有Thread 或者 Thread 子类才是线程对象。
* 问题二: 为什么 把Runnable实现类的对象作为实参传递给 Thread 类的对象
* 作用就是把Runnable实现类的对象的run方法
* 源码:
@Override
public void run() {
if (target != null) {
target.run();
}
}
推荐使用第二种: 实现 runnable 接口的, 因为 java单继承,多实现。
public class test_1 implements Runnable{ // 实现runnable接口
public static void main(String[] args) {
test_1 pTest_1 = new test_1(); // 创建runnable 实现类对象
//创建 Thread 类的对象,并且把Runnable实现类的对象作为实参传递
Thread thread = new Thread(pTest_1, "付祖贤女侠");
thread.start(); // 调用Thread 对象的start 方法开启一个线程
/*for(int i =0; i<5; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
} */
}
@Override
public void run() {
/*for(int i =0; i<5; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
} */
System.out.println("this: " + this);
System.out.println("当前线程: " + Thread.currentThread()); // 自定义线程的任务定义在run方法上
}
}
2. 线程常用的方法
* Thread(String name) 初始化进程的名字
* getName() 返回线程的名字
* setName(String name) 设置线程对象名
* sleep() 线程睡眠指定的毫秒数, !!!静态方法!!!,哪个线程执行了这个代码,那么就是哪个线程睡眠。
* getPriority() 返回当前线程对象的优先级,默认线程的优先级是5
* setPriority(int newPriority) 设置线程的优先级 1~10,10为最大的优先级
* currentThread() 返回CPU正在执行的线程的对象,!!!静态方法!!!!
public class test_1 extends Thread {
public test_1 (String name) {
super(name);
}
@Override
public void run() {
for(int i=0;i<5;i++) {
System.out.println(this.getName()+ ": " + i);
// 为什么在这里不能抛出异常,只能捕获?? 子类抛出异常必须小于或等于父类异常
/* try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} */
}
}
public static void main(String args[]) throws Exception {
// test_1 hh = new test_1();
// System.out.println("线程名称: " + hh.getName());
test_1 hhhh = new test_1("付祖贤");
// System.out.println("线程名称2: " + hhhh.getName());
// hhhh.sleep(1000); // 静态方法,是主线程在睡眠,因为这句代码是主线程执行
hhhh.setName(" 女侠 ");
hhhh.setPriority(10); // 优先级的数字越大,优先级越高,优先级的范围为: 1~10
hhhh.start();
for(int i=0;i<5;i++) {
System.out.println(Thread.currentThread().getPriority()+ ": " + i);
}
Thread mainthread = Thread.currentThread();
System.out.println("main: " + mainthread.getName());
// 线程的优先级默认为5
System.out.println("自定义的线程优先级: " + hhhh.getPriority());
System.out.println("主线程优先级: " + Thread.currentThread().getPriority());
}
}
************************* output *************************************
5: 0
5: 1
女侠 : 0
5: 2
女侠 : 1
5: 3
女侠 : 2
5: 4
女侠 : 3
main: main
女侠 : 4
自定义的线程优先级: 10
主线程优先级: 5
3. 线程安全问题
什么情况下才可能出现线程安全问题???
* 1. 存在两个或者两个以上的线程对象,而且线程之间共享一个资源* 2. 有多个语句操作共享资源
*
解决方法: sun提供了线程同步机制, java线程同步机制方式:
方式一: 同步代码块, 格式:
synchronzied(锁对象){ 需要被同步的代码...... }
同步代码块要注意的事项:
* 1. 任意的一个对象都可以作为锁对象。
* 2. 在同步代码块中sleep方法,并不会释放锁对象。
* 3. 只有真正存在线程安全问题的时候才使用同步代码块,否则会降低效率的
* 4. 多线程操作的锁对象必须是唯一共享的,否则无效
class Saleticket extends Thread{
static int num = 1000; // 静态的成员变量,该数据在每个对象都会维护一份数据
static Object object = new Object(); // 用static修饰!
public Saleticket(String num) {
super(num);
}
@Override
public void run() {
while(true) {
synchronized (object) { // 这个对象也得用static修饰!!!!
// synchronized ("锁对象") { // 这样也可以,字符串一旦创建,就不会再次创建
// synchronized (new String ("锁对象")) { // 这样也不行!!!
if(num>0) {
System.out.println(Thread.currentThread().getName() + "售出了第 " + num + " 号票");
num--;
}else {
System.out.println("售罄了......");
break;
}
}
}
}
}
public class test_1 extends Thread{
public static void main(String[] args) {
Saleticket sale1 = new Saleticket("第1窗口");
Saleticket sale2 = new Saleticket("第2窗口");
Saleticket sale3 = new Saleticket("第3窗口");
sale1.start();
sale2.start();
sale3.start();
}
}
********************** output ************************************
......
第1窗口售出了第 979 号票
第1窗口售出了第 978 号票
第1窗口售出了第 977 号票
第3窗口售出了第 976 号票
第3窗口售出了第 975 号票
第3窗口售出了第 974 号票
.....
第3窗口售出了第 1 号票
售罄了......
售罄了......
售罄了......
方式二: 同步函数 ,使用synchronized修饰一个函数
注意事项:
* 1. 如果是一个非静态的同步函数的锁对象是this对象,如果是静态的同步函数的锁对象是当前函数所属类的字节码文件( class 对象)
* 2. 同步函数的锁对象
class Saleticket extends Thread{
static int num = 6; // 静态的成员变量,该数据在每个对象都会维护一份数据
static Object object = new Object();
public Saleticket(String num) {
super(num);
}
@Override
public synchronized void run() { // 同步函数 ,使用synchronized修饰一个函数
while(true) {
// synchronized (object) {
if(num>0) {
System.out.println(Thread.currentThread().getName() + "售出了第 " + num + " 号票, 还剩下: " + (num-1) + "张");
num--;
}else {
System.out.println("售罄了......");
break;
}
// }
}
}
// 静态的函数-----》 函数所属类的字节码文件 ------》 Saleticket.class
public static synchronized void getnum() { // 一个线程全做完
}
}
public class test_1 extends Thread{
public static void main(String[] args) {
Saleticket sale1 = new Saleticket("第1窗口");
Saleticket sale2 = new Saleticket("第2窗口");
sale1.start();
sale2.start();
}
}
************************** output ******************************
第1窗口售出了第 6 号票, 还剩下: 5张
第2窗口售出了第 6 号票, 还剩下: 5张
第1窗口售出了第 5 号票, 还剩下: 4张
第2窗口售出了第 4 号票, 还剩下: 3张
第1窗口售出了第 3 号票, 还剩下: 2张
第2窗口售出了第 2 号票, 还剩下: 1张
第1窗口售出了第 1 号票, 还剩下: 0张
售罄了......
售罄了......
推荐使用: 同步代码
* 1. 同步代码的锁对象由我们随意指定,同步函数的锁对象是固定的,不能由我们指定
* 2. 同步代码可以很方便控制被同步代码的范围,同步函数必须是整个函数的所有代码都同步了!
4. 死锁现象
死锁现象原因: 存在两个或两个以上的线程; 存在两个或者两个以上的共享资源。 没有方案解决,避免发生!!!
class DeadLock extends Thread{
public DeadLock(String name) {
super(name);
}
@Override
public void run() {
if("女侠".equals(Thread.currentThread().getName())) {
synchronized ("遥控器") { //字符串常量池(String Pool)这部分也在方法区中,String Pool是JVM实例全局共享的,全局只有一个
System.out.println(" 女侠--遥控器,---> 电池 ");
synchronized ("电池") {
System.out.println(" 女侠全都搞定 ");
}
}
}else if ("仙女".equals(Thread.currentThread().getName())){
synchronized ("电池") {
System.out.println(" 仙女--电池,---> 遥控器 ");
synchronized ("遥控器") {
System.out.println(" 仙女全都搞定 ");
}
}
}
}
}
public class test_1 extends Thread{
public static void main(String[] args) {
DeadLock person1 = new DeadLock("女侠");
DeadLock person2 = new DeadLock("仙女");
person1.start();
person2.start();
}
}
5. 线程通讯
线程通讯: 一个线程完成了自己的任务,要通知另外的一个线程去完成另外一个任务
wait(): // 等待, 如果线程执行了 wait 方法,那么该线程就会进入等待的状态,必须要被其他的线程调用notify方法才能唤醒 // 调用wait方法,就会释放锁对象
notify(): // 唤醒, 唤醒以锁对象为标识符的线程,唤醒等待的线程 ,先等待的线程一般会先唤醒。
notifyAll(): 唤醒线程池中所有的线程
注意事项:
1. wait方法 和 notify方法是属于object对象的; 锁对象是object对象
2. 两个方法必须要在同步块或者同步函数中才能使用; 因为需要锁对象调用,同步代码中有锁对象
3. 这两种方法需要由锁对象调用,同一个锁对象! 一个锁对象建立一个线程池
例子: 生产者和消费者
class Product{ // 产品
String name;
double price;
boolean flag = false; // 是否开始的标志
}
class Producter extends Thread{ // 生产者
Product p;
public Producter(Product p) {
this.p = p;
}
@Override
public void run() {
int i = 0;
for(int t= 0; t<100; t++) {
synchronized (p) { // 出现价格错乱???? 需要同步
if(p.flag ==false) { // 消费者线程已经结束,生产线程开始进行
if(i%2==0) {
p.name = "柠檬";
p.price = 66.6;
}
else {
p.name = "百香果";
p.price = 33.3;
}
System.out.println("生产者生产出了: " + p.name + " 价格: " + p.price);
p.flag = true;
p.notify(); // 生产完,唤醒正在睡眠的消费者线程
i++;
}else {
try {
p.wait(); // 消费者线程正在进行,生产线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
class Customer extends Thread{ // 消费者
Product p;
public Customer(Product p) {
this.p = p;
}
@Override
public void run() {
for(int t= 0; t<100; t++) {
synchronized (p) { // 出现价格错乱???? 需要同步
if(p.flag ==true) {
System.out.println(" 付祖贤减肥成功 "+ p.name + " " + p.price);
p.flag = false;
p.notify();
}else {
try {
p.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class test_1 {
public static void main(String[] args) {
Product p = new Product(); //
Producter producter = new Producter(p);
Customer customer = new Customer(p);
producter.start();
customer.start();
}
}
6. 线程的停止
1. 停止一个线程,一般通过一个变量去控制。
2. 停止一个等待状态的线程,需要用一个变量配合 notify() 或者 interrupt()
public class test_1 extends Thread{
boolean flag= true;
public test_1(String name) {
super(name);
}
@Override
public synchronized void run() {
int i = 0;
while(flag) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+ ": " + i);
i++;
}
}
public static void main(String[] args) {
test_1 tt = new test_1("付祖贤女侠");
tt.setPriority(10);
tt.start();
for(int i=0; i<6; i++) {
System.out.println(Thread.currentThread().getName()+ ": " + i);
if(i==3) {
// tt.stop(); //
// tt.interrupt(); // 无法停止线程
tt.flag=false;
tt.interrupt(); // 把等待状态的线程清除,被清除的线程会收到 一个异常 InterruptedException
/* synchronized (tt) {
tt.notify(); // 不能指定唤醒哪个线程
} */
}
}
}
}
************************** output ********************************
main: 0
main: 1
main: 2
main: 3
main: 4
main: 5
java.lang.InterruptedException
付祖贤女侠: 0
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Unknown Source)
at test.test_1.test_1.run(test_1.java:14)
7. 守护线程(后台线程)Daemon
守护线程(后台线程): 在一个进程中如果只剩下了守护线程,那么守护线程也会死亡。
一个线程都不会默认为守护线程。设置: setDaemon();
public class test_1 extends Thread {
public test_1(String name) {
super(name);
}
@Override
public void run() {
for(int i= 0; i<20;i++) {
System.out.println("更新包目前下载了" + i + "%");
if(i==20) {
System.out.println("更新包下载完毕");
}
try {
this.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
test_1 tt = new test_1("后台线程");
tt.setDaemon(true); // 怎样成为守护线程 ?? main 线程结束之后,守护线程也死亡!
System.out.println("是守护线程吗? " + tt.isDaemon()); // 怎样判别守护线程??
tt.start();
for(int i= 0; i<20;i++) {
System.out.println(Thread.currentThread().getName() + i);
}
}
}
8. join 方法
class Washing extends Thread{ // washing类
@Override
public void run() {
System.out.println("付祖贤刷牙");
System.out.println("付祖贤洗脸");
System.out.println("付祖贤补水,发现喷雾没有了");
Spray spray = new Spray();
spray.start();
try {
spray.join(); // 加入, 由 washing类线程 来执行
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("付祖贤涂乳液");
System.out.println("付祖贤涂隔离霜");
System.out.println("付祖贤涂防晒霜");
}
}
class Spray extends Thread{ // 喷雾类
@Override
public void run() {
System.out.println("那就找屈臣氏的那瓶水");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("忘了那瓶水在哪?");
System.out.println("那瓶水在搁架上");
System.out.println("在搁架上找到了那瓶水");
}
}
public class test_1 {
public static void main(String[] args) {
Washing washing = new Washing();
washing.start();
}
}
************************** output **************************************
付祖贤刷牙
付祖贤洗脸
付祖贤补水,发现喷雾没有了
那就找屈臣氏的那瓶水
忘了那瓶水在哪?
那瓶水在搁架上
在搁架上找到了那瓶水
付祖贤涂乳液
付祖贤涂隔离霜
付祖贤涂防晒霜
//\\