Java 常用工具类--多线程
2018-09-16 本文已影响0人
磊_5d71
-
进程
进程是指可执行程序并存放在计算机存储器的一个指令序列，它是一个动态执行的过程。 -
线程
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。 -
线程的创建
1、创建一个Thread类，或者一个Thread子类的对象
2、创建一个实现Runnable接口的类的对象
image.png
-
Thread类
1、继承Object类
2、实现Runnable接口 -
Runnable接口
1、只有一个方法run();
2、Runnable是Java中用以实现线程的接口
3、任何实现线程功能的类都必须实现该接口
System.out.println快捷键 sysout option+/
通过Thread类创建线程
- 通过继承Thread类的方式创建线程类，重写run()方法。
- 例1
package com.alan.thread;
class MyThread extends Thread {
public void run() {
System.out.println(this.getName()+" 该线程正在执行");
}
}
public class ThreadTest {
//两个线程在运行一个是主方法的线程，另一个是mt线程
public static void main(String[] args) {
System.out.println("主线程1");
MyThread mt = new MyThread();
mt.start(); //通过start方法启动线程，而不是run方法，要注意下。 线程只能调用一次start方法
System.out.println("主线程2");
}
}
- 例2
package com.alan.thread1;
class MyThread extends Thread {
// 带参构造，直接通过父类带参构造函数赋值
public MyThread(String name) {
super(name);
}
// 重写run方法
public void run() {
for (int i = 0; i < 10; i++) {
//可以直接使用getName方法，因为这里继承了Thread,在其中有此方法
System.out.println(getName()+"正在运行第"+i+"次");
}
}
}
public class ThreadTest {
public static void main(String[] args) {
// 创建两个线程，带参构造直接赋值名称
MyThread mt1 = new MyThread("线程1");
MyThread mt2 = new MyThread("线程2");
//运行结果是随机的
mt1.start();
mt2.start();
}
}
实现Runnable接口创建线程
- 为什么要使用Runnable接口
1、Java不允许多继承，如果一个类已经继承了另一个类，就只能通过实现Runnable接口来创建线程
2、不打算重写Thread类的其他方法
3、实际情况使用Runnable接口的方式，应用的更广泛一些。
package com.alan.runnable;
class PrintRunnable implements Runnable{
int i = 1;
@Override
public void run() {
while(i<=10)
System.out.println(Thread.currentThread().getName()+" 正在运行"+(i++)+"次");
}
}
public class Test {
public static void main(String[] args) {
// 通过实现Runnable接口创建线程
//1、将实现Runnable接口的类实例化
PrintRunnable pr1 = new PrintRunnable();
//2、创建一个线程，构造函数中将pr1传入
Thread t1 = new Thread(pr1);
//3、将线程t1 start
t1.start();
//同理再创建一个线程
PrintRunnable pr2 = new PrintRunnable();
Thread t2 = new Thread(pr1); //当两个线程初始化用同一个实现runnable的对象赋值时，相当于两个线程同时完成一个任务。
t2.start();
}
}
线程的状态和生命周期
-
线程的状态
1、新建
2、可运行
3、正在运行
4、阻塞
5、终止
image.png
sleep方法使用
package com.alan.runnable;
class MyThread implements Runnable {
@Override
public void run() {
for (int i = 1; i <=15; i++) {
System.out.println(Thread.currentThread().getName() + "执行第" + i + "次");
//在run方法中调用sleep，一定要处理异常
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public class SleepDemo {
public static void main(String agrs[]) {
MyThread mt = new MyThread();
Thread t = new Thread(mt);
t.start();
Thread t1 = new Thread(mt);
t1.start();
}
}
join方法的使用
package com.alan.runnable;
class MyThread1 extends Thread {
public void run() {
for (int i = 1; i <= 300; i++)
System.out.println(getName() + "正在执行第" + i + "次");
}
}
public class JoinDemo {
public static void main(String[] args) {
MyThread1 mt = new MyThread1();
mt.start();
try {
//可以带参，也可以不带参，单位毫秒
mt.join(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for (int i = 1; i <= 20; i++) {
System.out.println("主线程正在执行第" + i + "次");
}
System.out.println("主程序运行结束！");
}
}
线程的优先级
-
Java为线程类提供了10个优先级
-
优先级可以用整数1-10表示，超过范围会抛出异常
-
main方法主线程默认优先级为5
-
数字越大，优先级越高
-
优先级常量
1、MAX_PRIORITY:线程的最高优先级10
2、MIN_PRIORITY:线程的最低优先级1
3、NORM_PRIORITY:线程的默认优先级5
package com.alan.runnable;
class MyThread2 extends Thread {
//带参构造
public MyThread2(String name) {
super(name);
}
public void run() {
for (int i = 1; i <= 20; i++)
System.out.println(getName() + "正在执行第" + i + "次");
}
}
public class PriorityDemo {
public static void main(String[] args) {
int mainPriority = Thread.currentThread().getPriority();
System.out.println("主线程的默认优先级为："+mainPriority);
MyThread2 mt1 = new MyThread2("线程1");
MyThread2 mt2 = new MyThread2("线程2");
mt1.setPriority(Thread.MAX_PRIORITY);
mt2.setPriority(Thread.MIN_PRIORITY);
mt1.start();
mt2.start();
}
}
线程同步
-
多线程运行问题
1、各个线程是通过竞争CPU时间而获得运行机会的
2、各线程什么时候得到CPU时间，占用多久，是不可预测的
3、 一个正在运行着的线程在什么地方被暂停是不确定的 -
synchronized关键字是一个线程运行结束后，其他线程才可以继续执行
public synchronized void saveAccount(){}
线程间通信
- Queue.java
package com.alan.queue;
public class Queue {
private int n;
boolean flag = false;
//消费
public synchronized int get() {
if(!flag) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("消费:"+n);
flag = false;
this.notifyAll();
return n;
}
//生产
public synchronized void set(int n) {
if(flag) {
try {
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("生产:"+n);
this.n = n;
flag = true;
//添加notifyAll方法，否则会造成死锁
this.notifyAll();
}
}
- Consumer.java
package com.alan.queue;
public class Consumer implements Runnable {
Queue queue;
public Consumer(Queue queue) {
super();
this.queue = queue;
}
@Override
public void run() {
while(true) {
queue.get();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
- Producer.java
package com.alan.queue;
public class Producer implements Runnable {
Queue queue;
public Producer(Queue queue) {
super();
this.queue = queue;
}
@Override
public void run() {
int i = 0;
while(true) {
queue.set(++i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
- Test.java
package com.alan.queue;
public class Test {
public static void main(String[] args) {
Queue queue = new Queue();
new Thread(new Producer(queue)).start();
new Thread(new Consumer(queue)).start();
}
}
