Java学习笔记7

线程状态

Thread.State线程会处于以下几个状态之一
New:尚未启动的线程处于此状态
Running:在Java虚拟机中执行的线程处于此状态
BLOCKED:被阻塞等待监视器锁定的线程处于此状态
WAITING;正在等待另一线程执行特定动作的线程处于此状态
TIMED_WAITING;正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMINATED:已退出的线程处于此状态
一个线程可以在给定的时间处于一个状态,该状态反映的是在虚拟机中的状态

package thread;

public class TestState {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("----");
        });
        //查看线程状态New
        Thread.State state=thread.getState();
        System.out.println(state);

        thread.start();//RUN
        state=thread.getState();
        System.out.println(state);

        while (state!=Thread.State.TERMINATED)
        {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state=thread.getState();
            System.out.println(state);
        }

    }
}

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行
线程优先级使用数字表示,范围为1~10
Thread.MIN_PRIORITY=1
Thread.MAX_PRIORITY=10
Thread.NORM_PRIORITY=5
使用以下方式改变或获取优先级
getPriority();setPriority(xx)
建议将优先级的设定放在start()调度前

守护线程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不必等待守护线程执行完毕
如:后台记录操作日志、监控内存、垃圾回收等待

package thread;

public class TestDaemon {
    public static void main(String[] args) {
        People people = new People();
        God god = new God();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认false为用户线程,否则为守护线程
        thread.start();//守护线程启动
        new Thread(people).start();
    }
}
class God implements Runnable{
    @Override
    public void run() {
        while (true)
        {
            System.out.println("上帝保佑你");
        }
    }
}
class People implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("你好,新的一天");
        }
    }
}

线程同步

由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问的冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排它锁,独占资源,其他线程必须等待,使用锁后释放锁即可,但存在以下问题
一个线程持有锁会导致所有其他需要这个锁的线程挂起
在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置,引起性能问题

package thread;

import java.awt.event.ActionListener;

public class TestSynchronized {
    public static void main(String[] args) {
        Account account=new Account(1000);
        new Bank(account,800).start();
        new Bank(account,600).start();
    }
}
class Account{
    int money;

    public Account(int money) {
        this.money = money;
    }

}
class Bank extends Thread{
    private Account account;
    private int getMoney;

    public Bank(Account account, int getMoney) {
        this.account = account;
        this.getMoney = getMoney;
    }
    //取钱
    @Override
    public void run() {
        synchronized (account) {
            if ((account.money - getMoney) < 0) {
                System.out.println("余额不足");
                return;
            }
            account.money = account.money - getMoney;
            System.out.println("成功取出" + getMoney);
        }
    }
}

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized关键字,它包括两种用法:synchronized方法和synchronized块
同步方法 public synchronized void method(int args){}
synchronized方法控制对"对象"的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,直到该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
若将一个大的方法申明为synchronized将会影响效率
synchronized修饰在方法上,多个线程调用同一个对象的同步方法会阻塞,调用不同对象的同步方法不会阻塞。

死锁

多个线程各自占有一些共享资源,并且相互等待其他线程占有的资源才能运行,而导致两个或多个线程都在等待对方释放资源,都停止执行的情形,某一个同步块同时拥有两个以上对象的锁时,就可能发生死锁问题。

Lock(锁)

从JDK5.0开始,Java提供了更强大的线程同步机制–通过显式定义同步锁对象来实现同步,同步锁使用Lock对象充当
Lock接口是控制多个线程对共享资源进行访问的工具,锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁,释放锁

package thread;

import java.util.concurrent.locks.ReentrantLock;

public class TicketThread implements Runnable {
    //定义lock锁
    private final ReentrantLock lock=new ReentrantLock();
    private int ticket=10;
    @Override
    public void run() {
        while (true)
        {
            lock.lock();//加锁
            if(ticket<=0)
            {
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"买到了第"+ticket--+"张票");
            lock.unlock();//解锁
        }
    }

    public static void main(String[] args) {
        TicketThread thread=new TicketThread();
        new Thread(thread,"用户1").start();
        new Thread(thread,"用户2").start();
        new Thread(thread,"用户3").start();
    }
}

synchronized与Lock的区别

Lock是显式锁(手动开启和关闭锁,别忘记关闭锁),synchronized是隐式锁,出了作用域自动释放
Lock只有代码块锁,synchronized有代码块锁和方法锁
使用Lock锁,JVM将花费较少的时间调度线程,性能更好,并且具有更好的扩展性(提供更多的子类)
优先使用顺序Lock>同步代码块(已经进入了方法体,分配了相应资源)>同步方法(在方法体之外)

线程通信-分析

这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间互为依赖,互为条件
对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,又需要马上通知消费者消费
对于消费者,在消费之后,要通知生产者已结束消费,需要生产新的产品以供消费
在生产者消费者中,仅有synchronized是不够的
synchronized可阻止并发更新同一个资源,实现了同步
synchronized不能用来实现不同线程之间的消息传递(通信)

并发协作模型“生产者/消费者模式”–>管程法

生产者:负责生产数据的模块(可能是方法,对象,线程,进程)
消费者:负责处理数据的模块(可能是方法,对象,线程,进程)
缓冲区:消费者不能直接使用生产者的数据,他们之间有个缓冲区
生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

package thread;
//生产的产品
class Chicken{
    int id;//编号

    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer{
    //定义容器大小
    Chicken[] chickens=new Chicken[10];
    //容器计数器
    int count=0;
    //生产者放入产品
    public synchronized void push(Chicken chicken)
    {
        //如果容器满了就需要等待消费者消费
        if(count==chickens.length)
        {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满,则将产品放入容器中
        chickens[count]=chicken;
        count++;
        //通知消费者消费
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized Chicken pop(){
        if(count==0)
        {//没有产品,等待生产者生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken=chickens[count];
        //消费之后,通知生产者生产
        this.notifyAll();
        return  chicken;
    }
}
class Product extends Thread{
    SynContainer container;
    public Product(SynContainer synContainer)
    {
        this.container=synContainer;
    }
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了"+i+"号鸡");
            container.push(new Chicken(i));
        }
    }
}
class Consumer extends Thread{
    SynContainer container;
    public Consumer(SynContainer synContainer)
    {
        this.container=synContainer;
    }
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了"+container.pop().id+"号鸡");
        }
    }
}
public class TestPC {
    public static void main(String[] args) {
        SynContainer container=new SynContainer();
        new Product(container).start();
        new Consumer(container).start();
    }
}

使用线程池

背景:经常创建和销毁,使用量特别大的资源,比如并发情况下的线程,对性能影响很多
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中,可以避免频繁创建销毁,实现重复利用,类似生活中的公共交通工具
好处:
提高响应速度(减少了创建新线程的时间);
降低资源消耗(重复利用线程池中线程,不需要每次都创建)
便于线程管理

  • corePoolSize:核心池大小
  • maximumPoolSize:最大线程数
  • keepAliveTime:线程没有任务时最多保持多长时间会终止
    JDK5.0起提供了线程池相关API:ExecutorService和Executors
    ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor
    void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
    Future submit(Callable task);执行任务,有返回值,一般用来执行Callable
    void shutdown();关闭连接池
    Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
package thread;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestPool {
    public static void main(String[] args) {
        //创建线程池,参数为线程个数
        ExecutorService pool= Executors.newFixedThreadPool(10);
        pool.execute(new Thread1());
        pool.execute(new Thread1());
        pool.execute(new Thread1());
        pool.execute(new Thread1());
        //关闭链接
        pool.shutdown();
    }
}
class Thread1 implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值