1.多线程
多线程的创建
方法一：继承Thread类
- 创建一个继承于Thread的子类
- 重写thread类的run()–将此线程的操作声明在run()中
- 创建Thread类的子类的对象
- 通过此对象调用start()
- start()-----作用：①此线程开始执行(启动此线程)；②Java虚拟机调用此线程中的run方法
public class Main {
public static void main(String[] args) {//主线程
Pthread p1 = new Pthread();
p1.start();//开启另一个线程
//下面还是主线程即在main线程中执行的
for(int i=0;i<100;i++){
if(i%2==0){
System.out.println(i+"主");
}
}
}
}
class Pthread extends Thread{
@Override
public void run(){
for(int i=0;i<100;i++){
if(i%2==0){
System.out.println(i);
}
}
}
}
注意：
- 我们不能通过直接调用run()的方式启动线程
- 想要再启动一个线程，不可以让已经启动start()的线程去执行，会报错IllegalThreadStateException，可以再创建一个子类启动线程
Thread中的常用方法
-
currentThread(): 静态方法，返回执行当前代码的线程
-
yield()：释放当前cpu的执行权
-
join()：在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态.
-
sleep(long millitime): 让当前线程“睡眠”指定的millitime毫秒，在指定的millitime毫秒实际内，当前线程是阻塞状态
-
isAlive()：判断当前线程是否存活，返回true或者false
获取和设置当前线程的优先级
- 线程的优先级等级
MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 - 涉及的方法
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级 - 说明
线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
方法二：实现Runnable接口
-
创建一个实现了Runnable接口的类
-
实现类去重写Runnable中的抽象方法：run()
-
创建实现类的对象
-
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
-
通过Thread类的对象调用start()----①启动线程
②调用当前线程的run()–调用了Runnable类型的target的run()方法
注意：此时是多个线程共用了一个run方法，即共享数据
比较创建线程的两种方式
开发中：优先选择：方法二–实现Runnable接口
原因：1. 实现的方式没有类的单继承性的局限性
- 实现的方式更适合来处理多个线程有共享数据的情况
创建线程的两种方式之间的联系
联系: public class Thread implements Runnable
相同点: 两种方式都需要重写run(), 将线程要执行的逻辑声明在run()中。
方式三：实现Callable接口
-
与使用Runnable相比，Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
-
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutrueTask是Futrue接口的唯一的实现类
- FutureTask 同时实现了Runnable, Future接口。它既可以作为
- Runnable被线程执行，又可以作为Future得到Callable的返回值
class NewThread1 implements Callable{
@Override
public Object call() throws Exception {
int sum=0;
for (int i = 1; i <=100 ; i++) {
if(i%2==0){
System.out.println(i);
sum+=i;
}
}
return sum;
}
}
public class ThreadNew3 {
public static void main(String[] args) {
NewThread1 n1 = new NewThread1();
FutureTask futureTask = new FutureTask(n1);
new Thread(futureTask).start();
try {
Object sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
方式四：线程池
多线程的安全问题
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有
执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以
参与执行。
Java对于多线程的安全问题提供了专业的解决方式：同步机制
同步的方式，解决了线程的安全问题。—好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。–局限性
1.同步代码块
synchronized (同步监视器(对象)){
// 需要被同步的代码；
//说明：1.操作共享数据的代码，即为需要被同步的代码
2.共享数据：多个线程共同操作的遍历。比如：ticket
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用一把锁。
}
2.同步方法
synchronized还可以放在方法声明中，表示整个方法为同步方法。
例如：
public synchronized void show (String name){ //同步监视器：this
….
}
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2.非静态的同步方法, 同步监视器是:this
静态的同步方法，同步监视器是:当前类本身
//单例模式的懒汉式安全问题--多线程解决
class Bank{
private Bank(){};
private static Bank instance = null;
public static Bank getInstance(){
//方式一：效率较差 因为会有多个线程进来等待着
// synchronized(Bank.class){
// if(instance == null){
// instance = new Bank();
// }
// }
// return instance;
//方式二：提高效率
if(instance == null){
synchronized(Bank.class){//同步代码块
if(instance == null){
instance = new Bank();
}
}
}
return instance;
}
}
线程死锁的问题
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃
自己需要的同步资源，就形成了线程的死锁
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于
阻塞状态，无法继续
- 我们使用同步时–要避免死锁
/*
此例子就会发生死锁的问题
问题在sleep位置
解释：由于两个线程共用了s1、s2这两把锁
在线程1执行到sleep的时候(s1这把锁被占用了)，线程2开始执行并使用了s2这把锁，相当于s2这把锁已经被占用了，线程1无法再往下执行(由于s2锁被占用的原因)，线程2也无法往下执行(因为s1锁被线程1占用没有释放)
因此两个线程互相等待对方让步--以至于死锁
*/
public class DeadLock1 {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
@Override
public void run() {
synchronized(s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized(s2){
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
3.Lock锁
public class ThreadTest3 {
public static void main(String[] args) {
Windoww1 ww1 = new Windoww1();
Thread t1 = new Thread(ww1);
Thread t2= new Thread(ww1);
Thread t3 = new Thread(ww1);
t1.setName("线程1");
t2.setName("线程2");
t3.setName("线程3");
t1.start();
t2.start();
t3.start();
}
}
class Windoww1 implements Runnable{
private int ticket = 100;
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock();//锁住
if(ticket>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"\t"+ticket--);
}
else break;
}finally {
lock.unlock();//开锁
}
}
}
}
注意：如果同步代码有异常，要将unlock()写入finally语句块
synchronized 与 Lock 的对比
-
Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
-
Lock只有代码块锁，synchronized有代码块锁和方法锁
-
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：
Lock >同步代码块（已经进入了方法体，分配了相应资源） > 同步方法（在方法体之外）
线程的通信
wait() 方法
-
在当前线程中调用方法： 对象名.wait()------由同步监视器来调用
-
使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
-
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
-
调用此方法后，当前线程将释放对象监控权 ，然后进入等待
-
在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。
-
调用之后会直接释放锁
notify()/notifyAll()
-
在当前线程中调用方法： 对象名.notify()------由同步监视器来调用
-
功能：唤醒等待该对象监控权的一个/所有线程。
-
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
public class ThreadTest5 {
public static void main(String[] args) {
Windoww2 ww1 = new Windoww2();
Thread t1 = new Thread(ww1);
Thread t2= new Thread(ww1);
//Thread t3 = new Thread(ww1);
t1.setName("线程1");
t2.setName("线程2");
// t3.setName("线程3");
t1.start();
t2.start();
//t3.start();
}
}
class Windoww2 implements Runnable{
private int ticket = 4;
@Override
public void run() {
while (true){
synchronized(this){
notify();
if(ticket>0){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"\t"+ticket--);
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
else break;
}
}
}
}
sleep()和wait()方法的异同
- 相同点:一旦执行方法，都可以使得当前的线程进入阻塞状态。
- 不同点:
- 两个方法声明的位置不同:Thread类中声明sleep() , object类中声明wait()
- 调用的要求不同: sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或者同步方法中。
- 关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
扫一扫
4073
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
