Java多线程的相关内容

最新推荐文章于 2024-08-12 10:15:58 发布

thisouou

最新推荐文章于 2024-08-12 10:15:58 发布

阅读量150

点赞数

分类专栏： Java Standard Edition

本文链接：https://blog.csdn.net/ouqianbei/article/details/107197379

版权

Java Standard Edition 专栏收录该内容

40 篇文章 0 订阅

订阅专栏

文章目录

线程

Thread类

实现多线程就要用到Thread类

构造方法

方法名	说明
public Thread()	分配一个新的线程对象。
public Thread(String name)	分配一个指定名字的新的线程对象。
public Thread(Runnable target)	分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name)	分配一个带有指定目标新的线程对象并指定名字。

常用方法

方法名	说明
public String getName()	获取当前线程名称。
public void start()	导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run()	此线程要执行的任务在此处定义代码。
public static void sleep(long millis)	使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread `currentThread()`	返回对当前正在执行的线程对象的引用。

创建线程的方式

创建线程的方式总共有两种

继承Thread类方式
实现Runnable接口方式

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

class myThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class example_1 {
    public static void main(String[] args) {
        myThread myThread = new myThread();
        Thread thread = new Thread(myThread, "老师");
        thread.start();
    }
}

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。

实现线程同步的方法

同步代码块
同步方法
锁机制

同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式:

synchronized(lock){
	.
	.
	.
}

同步锁:

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

锁对象可以是任意类型。
多个线程对象要使用同一把锁。

class SellTicket implements Runnable {
    private int tickets = 100;
    Object lock = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {   //同步代码块
                if (tickets > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            }
        }
    }
}

同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。

格式:

public synchronized void method(){
	.
	.
	.
}

例子:

class SellTicket implements Runnable {
    private int tickets = 100;

    @Override
    public void run() {
        while (true) {
            sell();
        }
    }

    private synchronized void sell() {
        if (tickets > 0) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
            tickets--;
        }
    }
}

锁机制

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SellTicket implements Runnable {
    private int tickets = 100;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();    //加同步锁
                if (tickets > 0) {
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            } finally { 
                lock.unlock();  //释放同步锁
            }
        }
    }
}