1、Process（进程）与Thread（线程）
- 说起进程，就不得不说下程序，程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念
- 而进程是执行程序的一次过程，它是一个动态的概念，是系统资源分配的单位
- 通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义，线程是CPU调度和执行的单位
- 在程序运行时，即时没有自己创建线程，后台也会有多个线程，如主线程，gc线程
- main（）称之为主线程，为系统的入口，，用于执行整个程序
2、线程的创建
2.1、继承Thread类（重点）
- 自定义线程类继承Thread类
- 重写run（）方法，编写线程执行体
- 创建线程对象，调用start（）方法启动线程
- 启动线程：子类对象.start（）
- 不建议使用：避免 OOP单继承局限性
public class Thread01 extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//两个线程同时执行
Thread01 thread01 = new Thread01();
thread01.start();
for (int i = 0; i < 200; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
2.2、实现Runnable（重点）
- 定义MyRunnable类实现Runnable接口
- 实现run（）方法，编写线程执行体
- 创建线程对象，调用start（）方法启动线程
- 启动线程：传入目标对象+Thread对象.start（）
- 推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被多个线程使用
public class Runnable_ implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
Runnable_ runnable_ = new Runnable_();
Thread runnable = new Thread(runnable_);
runnable.start();
// new Thread(runnable_).start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
- 买票例子：
发现问题：多个线程操作同一个资源的情况下，线程不安全，数据混乱
public class Runnable2_ implements Runnable{
//票数
private int ticketNums=10;
@Override
public void run() {
while(true){
if (ticketNums<=0){
break;
}
//模拟延时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-->拿到了第"+(ticketNums--)+"票");
}
}
public static void main(String[] args) {
Runnable2_ ticket = new Runnable2_();
new Thread(ticket,"小明").start();
new Thread(ticket,"老师").start();
new Thread(ticket,"黄牛").start();
}
}
2.3、实现Callable接口（了解）
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务：ExecutorService ser =Executors.newFixedThreadPool(1);
- 提交执行：Futrue< Boolean > result1=ser.submit(t1)；
- 获取结果：boolean r1=result.get()
- 关闭服务：ser.shutdownNow();
public class Callable_ implements Callable {
@Override
public Object call() throws Exception {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码---"+i);
}
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable_ t1 = new Callable_();
ExecutorService ser = Executors.newFixedThreadPool(1);
Future<Object> result = ser.submit(t1);
Object rs1 = result.get();
System.out.println(rs1);
ser.shutdown();
}
}
3、Lamda表达式
- 为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来很简洁
- 去掉一推没有意义的代码，只留下核心的逻辑
- 函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
public interface Runnable{
public abstract void run();
}- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
public class Lambda_ {
public static void main(String[] args) {
//匿名内部类
ILike iLike = new ILike() {
@Override
public void lambda(int a) {
System.out.println("1 like lambda1"+a);
}
};
iLike.lambda(520);
//lambda简化
iLike=(a)->{System.out.println("1 like lambda2"+a);
};
iLike.lambda(520);
//简化
iLike=(a)-> System.out.println("1 like lambda3"+a);
iLike.lambda(520);
}
}
//函数是接口
interface ILike{
void lambda(int a);
}
4、线程状态
4.1、线程方法
- setPriority（int newPriority）：更改线程的优先级
- static void sleep（long millis）：在指定的毫秒数内让当前正在执行的线程休眠
- viod join（）：等待该线程终止
- static void yield（）：暂停当前正在执行的线程对象，并执行其他线程
- void interrupt（）：中断线程，别用这个方法
- boolean idAlive（）：测试线程是否处于活动状态
- setPriority（）：设置线程优先级
5、守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 用户线程执行完毕，即守护线程也停止
- 如：后台记录操作日志，监控内存，垃圾回收等待
public class Runnable_3 {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认为false表示为用户线程，正常的线程都是用户线程
thread.start();//守护线程启动
new Thread(you).start();
}
}
class God implements Runnable{
@Override
public void run() {
while(true){
System.out.println("上帝保佑着你");
}
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("你一直活着");
}
System.out.println("good by");
}
}
6、线程同步
- 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排斥所，独占资源，其他线程必须等待，使用后释放锁即可，存在一下问题：
- 一个线程持有锁会导致其他所有需要次锁的线程挂起；
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题；
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题
public class 线程同步 {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"a").start();
new Thread(buyTicket,"b").start();
new Thread(buyTicket,"c").start();
}
}
class BuyTicket implements Runnable{
private int ticketNum=10;
boolean flag=true;
@Override
public void run() {
while(flag){
buy();
}
}
private synchronized void buy(){
if (ticketNum<0){
flag=false;
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"还剩"+ticketNum--);
}
}
7、死锁
- 多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都会停止执行的情况，某一个同步块同时拥有两个以上对象的锁时，就可能会发生死锁的问题
8、Lock锁
public class Lock_ {
public static void main(String[] args) {
Lock lock = new Lock();
new Thread(lock).start();
new Thread(lock).start();
new Thread(lock).start();
}
}
class Lock implements Runnable{
int ticket=10;
//定义lock锁（可重用锁）
private final ReentrantLock lock= new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock();//加锁
if (ticket>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticket--);
}else{
break;
}
}finally {
//解锁
lock.unlock();
}
}
}
}
9、synchronized与Lock的对比
- Lock是显示锁（手动开启和关闭锁，别忘记关闭所）synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性
- 优先使用顺序：
- Lock>同步代码块>同步方法
10、线程通信
11、线程池
113
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
