java多线程

多线程

1、概念

1.1 程序

1.2 进程

1.3 线程

2、线程的创建

2.1 概念

java.lang.Thread类代表线程，任何线程对象都是Thread类（子类）的实例。
Thread类是线程的模板，封装了复杂的线程开启等操作，封装了操作系统的差异性。

2.2 创建方式

自定义类继承Thread类并重写run方法，然后创建该类的对象调用start方法。
自定义类实现Runnable接口并重写run方法，创建该类的对象作为实参来构造Thread类型的对象，然后使用Thread类型的对象调用start方法。

public class ThreadTest {

    public static void main(String[] args) {

        Thread t1 = new ThreadTest1();
        t1.start();

        for (int i = 0; i < 4; i++) {
            System.out.println("zhuxiancheng");
        }
    }
}


public class ThreadTest1 extends Thread {

    @Override
    public void run() {
        System.out.println("这是一个线程");
    }
}

public class SubRunnableRun implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("线程" + i);
        }
    }
}



public class SubRunnableTest {

    public static void main(String[] args) {

        SubRunnableRun r = new SubRunnableRun();

        Thread t = new Thread(r);

        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程" + i);
        }
    }
}

2.3 常用方法


Thread()
Thread(String name)
Thread(Runnable target)
Thread(Runnable target, String name)
void run()
void star()

2.4 执行流程

执行main方法的线程叫做主线程，执行run方法的线程叫做新线程/子线程。
main方法是程序的入口，对于start方法之前的代码来说，由主线程执行一次，当start方法调用成功后线程的个数由1个变成了2个，新启动的线程去执行run方法的代码，主线程继续向下执行，两个线程各自独立运行互不影响。
当run方法执行完毕后子线程结束，当main方法执行完毕后主线程结束。
两个线程执行没有明确的先后执行次序，由操作系统调度算法来决定。

2.5 两种方法比较

继承Thread类的方式代码简单，但是若该类继承Thread类后则无法继承其它类，而实现
Runnable接口的方式代码复杂，但不影响该类继承其它类以及实现其它接口，因此以后的开发中推荐使用第二种方式。

2.6 使用匿名内部类的方式启动线程

package com.learn_java.qiyuan.moduleFourCoreClassAndLib.MyThread;

public class ThreadNonNameTest {

    public static void main(String[] args) {

        //1
        new Thread() {
            @Override
            public void run() {
                System.out.println("232");
            }
        }.start();

        //2
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("arfe");
            }
        };
        Thread t1 = new Thread(r);
        t1.start();

        //3
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("arfefra");
            }
        }).start();

        //4
        // Java8开始支持lambda表达式： (形参列表)->{方法体；}

        Runnable r1 = ()->System.out.println("arfe");
        new Thread(r1).start();
               
    }

}

3、线程生命周期

4、线程名称


long getId()
String getName()
void setName(String name)
static Thread currentThread()

/*
自定义类继承Thread类并重写run方法，在run方法中先打印当前线程的编号和名称，然后将线程
的名称修改为"zhangfei"后再次打印编号和名称。
要求在main方法中也要打印主线程的编号和名称。
*/
public class ThreadNameTest extends Thread{

    @Override
    public void run() {
        System.out.println("ID is "+ getId()+"name is "+ getName());

        setName("zhangfei");

        System.out.println("ID is "+ getId()+"name is "+ getName());
    }


    public static void main(String[] args) {

        ThreadNameTest t = new ThreadNameTest();
        t.start();

        Thread tmain = Thread.currentThread();
        System.out.println("ID is "+ tmain.getId()+"name is "+ tmain.getName());
    }
}

5、常用方法


static void yield()
static void sleep(times)
int getPriority()
void setPriority(int newPriority)
void join()
void join(long millis)
boolean isDaemon()
void setDaemon(boolean on)

6、线程同步机制

6.1 概念

当多个线程同时访问同一种共享资源时，可能会造成数据的覆盖等不一致性问题，此时就需要对线程之间进行通信和协调，该机制就叫做线程的同步机制。
多个线程并发读写同一个临界资源时会发生线程并发安全问题。
异步操作:多线程并发的操作，各自独立运行。
同步操作:多线程串行的操作，先后执行的顺序。

6.2 解决方案

6.3 实现方式

在Java语言中使用synchronized关键字来实现同步/对象锁机制从而保证线程执行的原子性，具体方式如下：
使用同步代码块的方式实现部分代码的锁定，格式如下：
```
synchronized(类类型的引用) {
编写所有需要锁定的代码；
}
```
- 使用同步方法的方式实现所有代码的锁定。
  直接使用synchronized关键字来修饰整个方法即可
  该方式等价于:
  synchronized(this)

import java.util.concurrent.locks.ReentrantLock;

public class AccountRunnaleTest implements Runnable {

    private int balance;
    private Demo dm = new Demo();
    private ReentrantLock lock = new ReentrantLock();

    public AccountRunnaleTest(int balance) {
        this.balance = balance;
    }

    public AccountRunnaleTest() {
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public /*synchronized*/ void run() {
        //synchronized (new Demo()) {

        lock.lock();
            System.out.println("线程" + Thread.currentThread().getName() + "已启动");

            int temp = getBalance();
            if (temp > 200) {
                System.out.println("正在出钞，请稍后");
                temp -= 200;

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票");

            } else {
                System.out.println("余额不足，请核实");
            }
            setBalance(temp);
            System.out.println("账户余额：" + getBalance());
            lock.unlock();
        //}
    }


    public static void main(String[] args) {

        AccountRunnaleTest acc = new AccountRunnaleTest(1000);

        Thread t1 = new Thread(acc);
        Thread t2 = new Thread(acc);

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //System.out.println("账户余额："+acc.getBalance());

    }
}

class Demo {
}

6.4 静态方法的锁定

当我们对一个静态方法加锁，如:
public synchronized static void xxx(){….}
那么该方法锁的对象是类对象。每个类都有唯一的一个类对象。获取类对象的方式:类名.class。
静态方法与非静态方法同时使用了synchronized后它们之间是非互斥关系的。
原因在于：静态方法锁的是类对象而非静态方法锁的是当前方法所属对象。

6.5 注意事项

多个需要同步的线程在访问同步块时，看到的应该是同一个锁对象引用。
在使用同步块时应当尽量减少同步范围以提高并发的执行效率。

6.6 线程安全和不安全类

StringBuffer类是线程安全的类，但StringBuilder类不是线程安全的类。
Vector类和 Hashtable类是线程安全的类，但ArrayList类和HashMap类不是线程安全的类。
Collections.synchronizedList() 和 Collections.synchronizedMap()等方法实现安全。

6.7 死锁的概念

线程一执行的代码：
public void run(){
	synchronized(a){ //持有对象锁a，等待对象锁b
		synchronized(b){
			编写锁定的代码;
		}
	}
}
线程二执行的代码：
public void run(){
	synchronized(b){ //持有对象锁b，等待对象锁a
		synchronized(a){
			编写锁定的代码;
		}
	}
}

在以后的开发中尽量减少同步的资源，减少同步代码块的嵌套结构的使用！

6.8 使用Lock实现线程同步

6.8.1 概念

从Java5开始提供了更强大的线程同步机制—使用显式定义的同步锁对象来实现。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
该接口的主要实现类是ReentrantLock类，该类拥有与synchronized相同的并发性，在以后的线程安全控制中，经常使用ReentrantLock类显式加锁和释放锁。

6.8.2 常用方法


ReentrantLock()
void lock()
void unlock()

6.8.3 与synchronized方法比较

Lock是显式锁，需要手动实现开启和关闭操作，而synchronized是隐式锁，执行锁定代码后自动
释放。
Lock只有同步代码块方式的锁，而synchronized有同步代码块方式和同步方法两种锁。
使用Lock锁方式时，Java虚拟机将花费较少的时间来调度线程，因此性能更好。

6.9 Object类常用方法


void wait()
void wait(long timeout)
void notify()
void notifyAll()

6.10 线程池

6.10.1 实现Callable接口

从Java5开始新增加创建线程的第三种方式为实现java.util.concurrent.Callable接口。


V call()	计算结果并返回

6.10.2 FuthreTask类

java.util.concurrent.FutureTask类用于描述可取消的异步计算，该类提供了Future接口的基本实
现，包括启动和取消计算、查询计算是否完成以及检索计算结果的方法，也可以用于获取方法调用后的返回结果。


Future Task(Callable callable)	根据参数指定的引用来创建一个未来任务
V get()	获取call方法计算的结果

6.10.3 线程池的由来

在服务器编程模型的原理，每一个客户端连接用一个单独的线程为之服务，当与客户端的会话结束时，线程也就结束了，即每来一个客户端连接，服务器端就要创建一个新线程。
如果访问服务器的客户端很多，那么服务器要不断地创建和销毁线程，这将严重影响服务器的性能。

6.10.4 概念和原理

线程池的概念：首先创建一些线程，它们的集合称为线程池，当服务器接受到一个客户请求后，就从线程池中取出一个空闲的线程为之服务，服务完后不关闭该线程，而是将该线程还回到线程池中。

在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，再把任务交给内部某个空闲的线程，任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

6.10.5 相关类和方法

从Java5开始提供了线程池的相关类和接口：java.util.concurrent.Executors类和
java.util.concurrent.ExecutorService接口。

其中Executors是个工具类和线程池的工厂类，可以创建并返回不同类型的线程池，常用方法如
下：


static ExecutorService newCachedThreadPool()	创建一个可根据需要创建新线程的线程池
static ExecutorService newFixedThreadPool(int nThreads)	创建一个可重用固定线程数的线程池
static ExecutorService newSingleThreadExecutor()	创建一个只有一个线程的线程池

其中ExecutorService接口是真正的线程池接口，主要实现类是ThreadPoolExecutor，常用方法
如下


void execute(Runnable command)	执行任务和命令，通常用于执行Runnable
Future submit(Callable task)	执行任务和命令，通常用于执行Callable
void shutdown()	启动有序关闭

posted @ 2021-03-27 21:33 千叶翔龙阅读(81) 评论(0) 收藏举报

刷新页面返回顶部

千叶翔龙