这篇文章主要讲解了JAVA多线程的用法，内容清晰明了，对此有兴趣的小伙伴可以学习一下，相信大家阅读完之后会有帮助。
线程概念
进程：启动一个应用程序就叫一个进程。 接着又启动一个应用程序，这叫两个进程。每个进程都有一个独立的内存空间；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程：线程是在进程内部同时做的事情，一个进程中可以有多个线程，这个应用程序也可以称之为多线程程序。
一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程调度：
创建多线程
方法一：创建Thread类的子类
//方法一：
//定义Thread类的子类，并重写该类的run()方法
public class MyThreadDemo01 extends Thread {
@Override
public void run() {
for (int i = 0; i < 20 ; i++) {
System.out.println(getName()+"-->"+i);
}
}
}//主线程
public class MainThread01 {
public static void main(String[] args) {
//创建Thread子类的实例，即创建了线程对象
MyThreadDemo01 thread01 = new MyThreadDemo01();
//调用线程对象的start()方法来启动该线程
thread01.start();
for (int i = 0; i < 10 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
方法二：实现Runnable接口
//方法二：
//定义Runnable接口的实现类，并重写该接口的run()方法，设置线程任务
public class MyThreadDemo02 implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
} //主线程
public class MainThread {
public static void main(String[] args) {
//创建Runnable实现类对象
MyThreadDemo02 runnable = new MyThreadDemo02();
//创建Thread类的对象，并且该对象构造方法中传递Runnable实现类对象
Thread thread02 = new Thread(runnable);
//调用Thread对象的start()方法来启动线程
thread02.start();
for (int i = 0; i < 20 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}方法三：匿名内部类方式
//方法三：匿名内部类
public class MainThread {
public static void main(String[] args) {
//Thread方式
new Thread(){
@Override
public void run() {
for (int i = 0; i < 10 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}.start();
//Runnable接口方式
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}).start();
////////////////////////////////////////////////
for (int i = 0; i < 20 ; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}线程安全问题
多线程访问共享数据，，且多个线程中对资源有写的操作，就会出现线程安全问题
线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步， 否则的话就可能影响线程安全。
解决线程安全问题采用线程同步机制，主要有以下三种方式：
同步代码块
同步代码块：synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
public class SafeRunnableDemo implements Runnable {
private int ticket = 100;
//同步代码块
//创建锁对象
Object lock = new Object();
@Override
public void run() {
while (true){
//锁住同步代码块
synchronized (lock){
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
ticket--;
}
}
}
}
}同步方法
同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着
public class SafeRunnableDemo implements Runnable {
private int ticket = 100;
//同步方法
//定义一个同步方法
public synchronized void lock(){
//同步方法锁住代码块
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
ticket--;
}
}
//重写run并使用同步方法
@Override
public void run() {
while (true){
lock();
}
}
}Lock锁
Lock提供了比synchronized更广泛的锁操作
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SafeRunnableDemo implements Runnable {
private int ticket = 100;
//Lock锁方法
//创建ReentrantLock对象
Lock lock = new ReentrantLock();
@Override
public void run() {
while (true){
//在可能出现问题的代码块之前用lock()方法
lock.lock();
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张");
ticket--;
}
//在可能出现问题的代码块之后用unlock()方法
lock.unlock();
}
}
}线程机制
一个调用了某个对象的 Object.wait() 方法的线程会等待另一个线程调用此对象Object.notify()方法 或 Object.notifyAll()方法。
其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系， 多个线程会争取锁，同时相互之间又存在协作关系。
当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入 了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了 notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入 Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。
public class WaitAndSleep {
public static void main(String[] args) {
//创建锁对象
Object lock = new Object();
//匿名内部类创建线程1
new Thread(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"需要买票");
//用同步代码块包裹
synchronized (lock){
try {
//lock.wait(5000);//到5秒自动醒来
lock.wait();//进入无限等待，需要唤醒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"买到了票");
}
}.start();
//匿名内部类创建线程2
new Thread(){
@Override
public void run() {
try {
Thread.sleep(5000);//等待5秒
System.out.println(Thread.currentThread().getName()+"出票了");
} catch (InterruptedException e) {
e.printStackTrace();
}
//用同步代码块包裹
synchronized (lock){
lock.notify();//如果有多个线程等待，随机唤醒一个
//lock.notifyAll();//唤醒所有等待的线程
}
}
}.start();
}
}线程池
当在系统中用到了很多的线程，大量的启动和结束动作会导致系统的性能变卡，响应变慢，采用线程池可以解决这个问题。线程池就相当于一个容器（如同ArrayList），执行的任务放入线程池中，多出来的任务就等待线程池中的任务执行完再放入。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//线程池
public class ThreadPoolMain {
public static void main(String[] args) {
//使用线程池的工厂类 Executors里的静态方法 newFixedThreadPool
// 生产指定线程数量的线程池，返回为ExecutorService接口
ExecutorService es = Executors.newFixedThreadPool(2);
//调用ExecutorService中的submit方法，传递线程任务，开启线程
es.submit(new ThreadPoolDemo01());
}
}
//////////////////////////////////////////////////////
//创建一个类实现Runnable接口，重写run方法，设置线程任务
public class ThreadPoolDemo01 implements Runnable{
@Override
public void run() {
...
}
}看完上述内容，是不是对JAVA多线程的用法有进一步的了解，如果还想学习更多内容，欢迎关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
