线程
创建线程的方式
继承Thread,并实现run方法;new一个对象,调用start()方法,开启一个线程
实现Runnable接口,并实现run 方法,new Thread对象,把Runnable的实现类放到里面,然后调用Thread的start方法。
public class useThread {
public static void main(String[] args) {
// extendThread extendThread = new extendThread();
// extendThread extendThread1 = new extendThread();
// extendThread.setName("thread 1");
// extendThread1.setName("thread 2");
//
// // 调用 run方法,只是普通的调用方法,调用start才是启动一个新的线程。
// extendThread.start();
// extendThread1.start();
importThread importThread = new importThread();
importThread importThread1 = new importThread();
Thread t1 = new Thread(importThread);
Thread t2 = new Thread(importThread1);
t1.setName("thead 1");
t2.setName("thread 2");
t1.start();
t2.start();
}
}
//继承
class extendThread extends Thread{
//从写run
@Override
public void run() {
for(int i = 0 ;i < 100 ;i ++ )
System.out.println( getName() +"继承Thread类");
}
}
//实现
class importThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++){
//获得当前线程
Thread thread = Thread.currentThread();
System.out.println(thread.getName() + "Hello,world!");
}
}
}
使用Callable 和 Future;这种方式可以获得多线程运行的结果;创建一个类实现Callable ,泛型是多线程要返回的结果;创建一个类,实现Callable接口,重写call方法,创建一个实现类的对象(表示要执行的对象),创建FutureTask对象(管理多线程运行的结果),创建Thread类对象,启动;通过FutureTask对象可以获得线程执行的结果。
public class useThread {
public static void main(String[] args) {
myCallable myCallable = new myCallable();
FutureTask ft = new FutureTask(myCallable);
Thread thread = new Thread(ft);
thread.start();
//获取线程调用结果
try {
System.out.println("多线程调用的结果:" + ft.get());
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
}
}
class myCallable implements Callable {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
@Override
public Integer call() throws Exception {
int sum = 0;
for(int i = 1;i <= 100 ;i +=1 ) sum += i;
return sum;
}
}
选择:
简单就选继承Thread,需要扩展用Runable接口;需要结果就Callable。
常用的成员方法
getName() ,可以使用t.setName(”)设置线程名字,默认是Thread-0。
setName()或者创建对象的使用可以使用 Thread(String name) 这个构造器。
构造方法是不能继承的,如果子类想要使用父类的构造方法,可以自己写一个构造方法,然后去调用父类的构造方法。
currentThread() — static获得当前运行的线程,可以获得线程信息。
当JVM启动后,会自动调用多条线程,其中一条线程就是main线程,它的作用就是执行main方法,并执行里面的内容。
sleep() — static让线程休眠
那条线程执行这个方法,就停留多少时间,单位是毫秒。
当时间到了之后,会继续执行下面的代码。
父类中的方法没有抛出异常,继承后的子类方法,也就不能抛出异常,必须使用try-catch
setPriority(int newPriority) 设置线程的优先级。
默认是5,最大是10,最小是1。
priority越大,被执行的概率越高,但并不是按照比例去执行。
setDaemon(boolean on) 设置为守护线程。
当其他的非守护线程执行完毕之后,守护线程会陆续结束。
应用场景:聊天和文件的上传,当聊天关闭的时候,文件也没有上传的必要了,所以:在这里文件上传就是守护线程。
yield() — static 出让线程
只是出让,但是不一定也会让别人抢到线程。
join() 插入线程
插入线程到当前线程之前,只有等到插入的线程执行完之后,才会执行当前线程。
线程的生命周期
不安全的问题
public class part1 {
public static void main(String[] args) throws InterruptedException {
myThread t1 = new myThread("window1");
myThread t2 = new myThread("window2");
myThread t3 = new myThread("window3");
t2.start();
t1.start();
t3.start();
}
}
class myThread extends Thread{
public myThread(String name){
super(name);
}
public myThread(){
super();
}
static int ticket = 0;
@Override
public void run() {
while(true){
if(ticket " + ticket);
}else{
break;
}
}
}
}
出现重复售票
cpu的执行权,随时可能被其他线程抢占。
票多买
在99的时候,通过有多个线程进入while循环。
解决方案:—- 加锁
同步代码块
synchronized(里的锁对象一定要是唯一的)
public class part1 {
public static void main(String[] args) throws InterruptedException {
myThread t1 = new myThread("window1");
myThread t2 = new myThread("window2");
myThread t3 = new myThread("window3");
t2.start();
t1.start();
t3.start();
}
}
class myThread extends Thread{
public myThread(String name){
super(name);
}
public myThread(){
super();
}
static int ticket = 0;
//锁对象一定是唯一的。
static Object obj = new Object();
@Override
public void run() {
while(true){
synchronized (obj){
if(ticket < 100){
//锁住操作票的代码
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "窗口出售第" + ++ticket + "票");
}else{
break;
}
}
}
}
}
同步方法
修饰符 synchronized 返回值类型 方法名() {....}
特点
同步方法锁住的是方法里的全部代码
锁对象不能指定:
非静态: this
静态: class
锁对象是:this,也能保持线程同步,因为这里始终都是一个对象。
public class part1 {
public static void main(String[] args) throws InterruptedException {
myThread1 myThread1 = new myThread1();
new Thread(myThread1,"窗口2").start();
new Thread(myThread1,"窗口1").start();
}
}
class myThread1 implements Runnable{
int ticket = 0 ; //注意这里的ticket并不用一定是静态的,因为这个对象创建后,是作为参数在Thread执行的,只有一份
@Override
public void run() {
while(true){
if (extracted()) break;
}
}
private synchronized boolean extracted() {
if(ticket < 100){
//锁住操作票的代码
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "窗口出售第" + ++ticket + "票");
}else{
return true;
}
return false;
}
}
Lock
public class part1 {
public static void main(String[] args) throws InterruptedException {
new myThread("窗口1").start();
new myThread("窗口2").start();
}
}
class myThread extends Thread{
public myThread(String name){
super(name);
}
public myThread(){
super();
}
static int ticket = 0;
//需要共享同一把锁
static Lock lock = new ReentrantLock();
@Override
public void run() {
while(true){
//锁住操作票的代码
lock.lock();
if(ticket < 100){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "窗口出售第" + ++ticket + "票");
}else{
break;
}
lock.unlock();
}
}
}
上面这段代码有点问题,如果通过if break了,跳出循环后,就会导致锁没有释放,然后就会导致程序堵塞,稳妥的写法是把释放锁的操作放的finally中进行,因为无论如何finally中的代码肯定是要执行的。
@Override
public void run() {
while(true){
//锁住操作票的代码
lock.lock();
try {
if(ticket < 100){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "窗口出售第" + ++ticket + "票");
}else{
break;
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
lock.unlock();
}
}
}
死锁
死锁是一个常见的错误。
public class part1 {
public static void main(String[] args) throws InterruptedException {
new myThread("a").start();
new myThread("b").start();
}
}
class myThread extends Thread{
public myThread(String name){
super(name);
}
static Object objA = new Object();
static Object objB = new Object();
@Override
public void run() {
while(true){
if("a".equals(this.getName())){
synchronized (objA){
System.out.println("线程A拿到A锁,准备拿B锁");
synchronized (objB){
System.out.println("线程A拿到B锁,执行完成!");
}
}
}else if("b".equals(this.getName())){
synchronized (objB){
System.out.println("线程B拿到B锁,准备拿A锁");
synchronized (objA){
System.out.println("线程B拿到A锁,执行完成!");
}
}
}
}
}
}
生产者和消费者
生产者消费者模式是一个十分经典的多线程协作的模式。
生产者
//生产者线程
public class Cook extends Thread{
@Override
public void run() {
while(true){
synchronized (dest.lock){
if(dest.count == 0){
break;
}else{
//判断桌子上是否有食物
if(dest.status == 1){
try {
dest.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
//没有食物
System.out.println("做了一碗");
//修改桌子上食物的状态
dest.status = 1;
//叫醒消费者
dest.lock.notifyAll();
}
}
}
}
}
}
消费者
public class Foodie extends Thread{
public void run() {
/*
1.循环生产
2.同步代码
3.判断共享数据
*/
while(true){
synchronized (dest.lock){
if(dest.count == 0)
break;
else{
//判断桌子上是否有面条
if(dest.status == 0){
// 没有就等待,唤醒厨师
System.out.println("厨师生产面条");
try {
dest.lock.wait(); //让当前线程根锁进行绑定
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
//把吃的总数--
dest.count -- ;
// 有就开吃
System.out.println("开吃,开吃,还剩下 " + dest.count+ " 碗");
// 吃完之后,厨师继续做饭
dest.lock.notifyAll(); //唤醒所有的线程
//修改桌子的状态
dest.status = 0;
}
}
}
}
}
}
//控制生产者和消费者的执行
public class dest {
public static int status = 0;
public static int count = 10 ;
//锁对象
public static final Object lock = new Object();
}
等待唤醒机制(阻塞队列)
生产者
public class Cook extends Thread{
ArrayBlockingQueue queue;
public Cook(ArrayBlockingQueue queue) {
this.queue = queue;
}
@Override
public void run() {
while(true){
//不断地把面条放到阻塞队列中去
try{
queue.put("面条");
System.out.println("厨师放了一碗面条");
} catch(Exception e){
e.printStackTrace();
}
}
}
}
消费者
public class Foodie extends Thread{
ArrayBlockingQueue queue;
public Foodie(ArrayBlockingQueue queue)
{
this.queue = queue;
}
@Override
public void run() {
while(true){
try {
String peek = queue.take();
System.out.println(peek);
}catch (Exception e){
e.printStackTrace();
}
}
}
}
Test
public class Test {
public static void main(String[] args) {
ArrayBlockingQueue strings = new ArrayBlockingQueue(3);
Cook cook = new Cook(strings);
Foodie foodie = new Foodie(strings);
cook.start();
foodie.start();
}
}
ArrayBlockingQueue
和LinkedBlockingQueue
实现的接口有Queue,Collection,BlockingQueue和Iterator等接口。
ArrayBlockingQueue 底层是数组,需要指定队列大小。
put
放入一个元素。
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
//如果当前队列是满的,就等待。
while (count == items.length)
notFull.await();
//否则就入队。
enqueue(e);
} finally {
//最后释放锁。
lock.unlock();
}
}
take
往队列拿出一个元素。
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
//如果队列长度是0,就等待。
while (count == 0)
notEmpty.await();
//否则就拿出一个元素。
return dequeue();
} finally {
//最后释放锁
lock.unlock();
}
}
线程的状态
new — 新建 — 创建线程对象
Runable — 可执行状态 — start方法
Blocked — 阻塞状态 — 无法获得锁对象
Waiting — 等待状态 — wait方法
Timed_Waitting — 计时等待状态 — sleep方法
Terminated — 结束状态 — 全部代码执行完毕