一、创建线程三种方式
1.1 继承Thread类创建线程类（main线程与t线程交替执行）
1.2 通过Runnable接口创建线程类
弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂
上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。
public class RunnableThreadTest implements Runnable {
private int i;
public void run() {
for (i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
if (i == 2) {
RunnableThreadTest rtt = new RunnableThreadTest();
new Thread(rtt, "新线程1").start();
new Thread(rtt, "新线程2").start();
}
}
}
}使用Lambda表达式
public class RunnableThreadTest {
// 目的是为了代码的重用【静态方法】
public static void threadRunCode_Static() {
System.out.println(Thread.currentThread().getName() + " " +
}
// 目的是为了代码的重用【非静态方法】
public void threadRunCode() {
System.out.println(Thread.currentThread().getName() + " " + i);
}
@Test
public void testNoStatic() {
// 重用非静态方法中的代码【使用方法引用】
RunnableThreadTest temp = new RunnableThreadTest();
new Thread(temp::threadRunCode, "线程1").start();
}
@Test
public void testStatic() {
// 重用静态方法中的代码【使用方法引用】
new Thread(RunnableThreadTest::threadRunCode_Static, "线程1").start();
}
@Test
public void testLambda() {
// 重用静态方法中的代码【使用方法引用】
new Thread(() -> { System.out.println(Thread.currentThread().getName() + " " + b);
},"线程1").start();
}
匿名内部类实现线程
1、继承Thread类
new Thread() { //1.继承Thread类
public void run(){ //2.重写run方法
for(int i = 0;i < 1000;i++) {
System.out.println("aaaaaa");
}
}
}.start(); //3.开启线程2、实现Runnable接口
new Thread(new Runnable() { //1.将Runnable子类对象传递给Thread构造方法
public void run(){ //2.重写run方法
for(int i = 0;i < 1000;i++) {
System.out.println("bb");
}
}
}).start(); //3.开启线程1.3 线程的第三种创建方式
-
使用Callable接口_java.util.concurrent
image
- Callable接口与Runnable接口的区别：
- Runnable没有返回值一说，而且run()方法并不抛出异常
- Callable中的call方法具有返回值
- Callable之所以有返回值，也是因为实现了泛型，而Runnable接口不存在泛型
- Callable接口与Runnable接口的区别：
7.1 FutureTask类的学习——java.util.concurrent.FutureTask<V>
image
- FutureTask的构造器
image
-
此时可理解为：FutureTask的作用就是接收一个实现了Callable接口的实现类对象
-
此时注意到FutureTask实现了Runnable接口
- 也就是说可以把FutureTask的实现类对象传入到Runnable类型
- 而Thread类中的构造器的参数为Runnable类型
-
因此梳理后可知
①先实现Callable接口
class myThread_3 implements Callable<String>{ @Override public String call() throws Exception { return "线程创建成功"; } }②将Callable实现类对象传给FutureTask构造器
FutureTask<String> ft = new FutureTask<>(new myThread_3()); * 因为FutureTask实现了Runnable接口，因此以下代码也正确 Runnable runner = new FutureTask<String>(new myThread_3()); * 接口引用指向实现类对象 * 但是此时runner只能访问Runnable中方法，不可以访问FutureTask中的方法③创建线程并启动
new Thread(ft).start();④使用FutureTask类中方法
public V get() throws InterruptedException,ExecutionException 通过Thread启动线程之后 可以通过FutureTask存在get方法可以取得call（）方法中的返回值 /*用到Callable有什么用？只是为了返回一个值？执行线程的代码run用什么代替？*/ /*回答：此时线程启动start()方法调用的是call()方法，将需要执行的代码放到call()方法中，同时call()方法的特点在于有返回值*/ -
程序
public class TestCallable{ public static void main(String[] args) { FutureTask<String> ft = new FutureTask<String>(new myThread_3()); new Thread(ft).start(); //此时的启动需要调用的是call()方法 String result = null; try { result = ft.get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } System.out.println(result); } } class myThread_3 implements Callable<String>{ @Override public String call() throws Exception { System.out.println("此时start()方法调用的是call()方法"); return "线程创建成功"; } } /* 在JDK1.8中输出结果为： * ---------------------------- * 此时start()方法调用的是call()方法 线程创建成功 ---------------------------- * */
2. 多线程(获取名字和设置名字)(掌握)
Thread.currentThread()方法返回当前正在执行的线程对象
-
Thread类中的方法使用
- getName()
- setName()
- currentthread()
- sleep
- join
- wait
- yield
- setDaemon
-
获取名字【通过getName()方法获取线程对象的名字】
-
public final String getName();
-
-
设置名字
-
通过构造函数可以传入String类型的名字
public Thread(String name) public Thread(Runnable target,String name) -
通过setName(String)方法可以设置线程对象的名字
public final void setName(String name);
-
-
程序实现
new Thread("线程一") { //设置线程名字 public void run() { 设置代码块 for(int i = 0;i < 100;i++) { System.out.println(this.getName() + "....aaaa"); //获取线程名字 } } }.start(); new Thread() { public void run() { this.setName("线程3"); //设置线程名字 for(int i = 0;i < 100;i++) { System.out.println(this.getName() + "....哈哈"); } } }.start();
3. 多线程(获取当前线程的对象)(掌握) 【线程A与线程B 并发执行，顺序不定】
带参的构造函数
public Thread(String name)
public Thread(Runnable target,String name) public static Thread currentThread()
Thread.currentthread();——注意返回值是Thread
//匿名内部类实现当前线程对象的获取
new Thread() {
public void run() {
this.setName("线程A");
for(int i = 0;i < 1000;i++) {
System.out.println( Thread.currentThread().getName() + "....aaaa");
}
}
}.start();
匿名构造块作为参数
new Thread(new Runnable() {
public void run() {
for(int i = 0;i < 1000;i++) {
System.out.println( Thread.currentThread().getName() + "....bb");
}
}
},"线程B").start();
}
4. 多线程(休眠线程)(掌握)
-
public static void sleep(long millis) throws InterruptedException
- 抛出InterruptionException
public class TestSleepOfThread {
public static void main(String[] args) {
Runnable r = ()->{
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread A");
};
new Thread(r).start();
System.out.println("main Thread");
}
}
/*
* 在JDK1.8中输出结果为：
* -------------
* main Thread
Thread A
-------------
* */
5. 多线程(守护线程)(掌握)
-
setDaemon(), 设置一个线程为守护线程, 该线程不会单独执行, 当其他非守护线程都执行结束后, 自动退出
-
public final void setDaemon(boolean on)
-
on - if true, marks this thread as a daemon thread
public class TestSetDaemon { public static void main(String[] args) { Thread t1 = new Thread("线程A") { public void run() { for(int i = 0;i < 2;i++) { System.out.println(Thread.currentThread().getName() + "....aaaa"); } } }; Thread t2 = new Thread(new Runnable() { public void run() { for(int i = 0;i < 50;i++) { System.out.println(Thread.currentThread().getName() + "....bb"); } } },"线程B"); 将t2设置为守护线程 t2.setDaemon(true); //将t2设置为守护线程 t1.start(); t2.start(); } } /* * 在JDK1.8中输出结果为： * ------------------------ * 线程A....aaaa 线程B....bb 线程A....aaaa 线程B....bb //存在时间缓冲问题 线程B....bb 线程B....bb 线程B....bb 线程B....bb 线程B....bb 线程B....bb * */
-
6. 多线程(加入线程)(掌握)
-
join(), 当前线程暂停, 等待指定的线程执行结束后, 当前线程再继续
-
t1.join(); 当前线程暂停直到 线程t1执行完毕
-
join(int), 可以等待指定的毫秒之后 当前线程继续
-
public final void join() throws InterruptedException
public class TestJoin { public static void main(String[] args) { Thread t1 = new Thread("线程A") { public void run() { for(int i = 0;i < 100;i++) { System.out.println(getName() + "....aaaaaaa"); } } }; Runnable r = ()->{ for(int i = 0;i < 50;i++) { if(i == 2) { try { t1.join(); 当前线程暂停知道 线程t1执行完毕 //t1.join(1000); t1插队执行1秒后，t1和t2线程再抢占CPU交替执行 } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(Thread.currentThread().getName() + "....bb"); } }; t1.start(); new Thread(r).start(); } }
13. 多线程(礼让线程)(了解)
- yield让出cpu
14. 多线程(设置线程的优先级)(了解)
- setPriority()设置线程的优先级
15. 多线程(同步代码块)(掌握)
- 1.什么情况下需要同步
- 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
- 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
- 2.同步代码块
-
使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
-
锁对象不可以用匿名对象，因为匿名对象不是同一个对象
-
多个同步代码块如果使用相同的锁对象, 那么他们就是同步的
public class TestTickets_2 { public static void main(String[] args) { MyThread_6 myt = new MyThread_6(); new Thread(myt,"线程A").start(); new Thread(myt,"线程B").start(); } } class MyThread_6 implements Runnable{ private int ticket = 5; @Override public void run() { while(true) { if(this.ticket > 0) { System.out.println(Thread.currentThread().getName() + "开始卖票 = " + ticket--); } else { System.out.println("票已经卖完"); break; } } } }
-
16. 多线程(同步方法)(掌握)
public class TestSynchronized_2 {
public static void main(String[] args) {
Printer_2 p = new Printer_2();
Runnable r = ()->{
for(int i = 0;i < 100;i++) {
p.print1();
}
};
Thread t2 = new Thread() {
public void run() {
for(int i = 0;i < 100;i++) {
p.print2();
}
}
};
new Thread(r).start();
t2.start();
}
}
class Printer_2{
同步代码块
public synchronized void print1() {
System.out.print("早");
System.out.print("上");
System.out.print("好");
System.out.print("啊");
System.out.print("\r\n");
}
public void print2() {
synchronized(this) {
System.out.print("河");
System.out.print("正");
System.out.print("宇");
System.out.print("好");
System.out.print("帅");
System.out.print("\r\n");
}
}
}
17. 多线程(线程安全问题)(掌握)
-
多线程并发操作同一数据时, 就有可能出现线程安全问题
-
使用同步技术可以解决这种问题, 把操作数据的代码进行同步, 不要多个线程一起操作
/* * 铁路售票，一共100张，通过四个窗口卖完 * */ public class TestSynchronized_3 { public static void main(String[] args) { new Ticket().start(); new Ticket().start(); new Ticket().start(); } } class Ticket extends Thread{ private static int ticket = 100; public void run() { while(true) { //synchronized(this) synchronized(Ticket.class) { if(ticket == 0) { break; } System.out.println(getName() + "这是第" + ticket-- + "号票"); } } } }
18. 多线程(火车站卖票的例子用实现Runnable接口)(掌握)
public class TestSynchronized_4 {
public static void main(String[] args) {
Ticket_2 t = new Ticket_2();
new Thread(t,"线程A").start();
new Thread(t,"线程B").start();
new Thread(t,"线程C").start();
new Thread(t,"线程D").start();
}
}
class Ticket_2 implements Runnable{
private int ticket = 100; //此时ticket不需要设置为共享，因为均为同一对象
@Override
public void run() {
while(true) {
synchronized(this) {
if(ticket == 0) {
break;
}
System.out.println(Thread.currentThread().getName() + " 这是第" + ticket-- + "号票");
}
}
}
}
19. 多线程(死锁)(了解)
public class TestDeadLock {
private static Object o1 = new Object();
private static Object o2 = new Object();
public static void main(String[] args) {
new Thread("线程A") {
public void run() {
while(true) {
synchronized(o1) {
System.out.println(getName() + "正在使用o1,等待o2");
synchronized(o2) {
System.out.println(getName() +"等到o2，执行成功");
}
}
}
}
}.start();
new Thread("线程B") {
public void run() {
while(true) {
synchronized(o2) {
System.out.println(getName() + "正在使用o2,等待o1");
synchronized(o1) {
System.out.println(getName() + "等到o1,执行成功");
}
}
}
}
}.start();
}
}
/*
* 在JDK1.8中输出结果为：
* ----------------------
线程A正在使用o1,等待o2
线程A等到o2，执行成功
线程A正在使用o1,等待o2
线程B正在使用o2,等待o1
-------------------------
* */
- 因此：synchronized不要嵌套使用，容易出错
20. 多线程和队列实现买卖票
Queue接口
public interface Queue {
public void append(Object obj)throws Exception;
public Object delete()throws Exception;
public Object getFront()throws Exception;
public boolean isEmpty();
}
Class MyQueue
public class MyQueue implements Queue{
//1 设置队列的默认长度
static final int DEFAULT_SIZE=10; //默认长度为10
//2 设置队头
int front;
//3 设置队尾
int rear;
//4 定义统计元素的变量
int count;
//5 队的最大长度
int maxSize;
Object[] queue; //设置队列
//空构造
public MyQueue() {
this.init(DEFAULT_SIZE); //用户给定长度 默认长度为10
}
//有参数的构造
public MyQueue(int size) {
this.init(size); //开辟用户给定的长度
}
/**
* 初始化方法
* @param size
*/
public void init(int size) {
//初始化属性
this.maxSize=size; //外部传进来的size
//空队列
front=rear=0;
count=0;
queue=new Object[size];
}
@Override
public void append(Object obj) throws Exception {
// TODO Auto-generated method stub
//首先队列是否已满
if(count>0&&front==rear) { //判断队列是否已满
throw new Exception("队列已满");
}
this.queue[rear]=obj;
rear=(rear+1)%maxSize;
count++;
}
@Override
public Object delete() throws Exception {
// TODO Auto-generated method stub
if(this.isEmpty()) {
throw new Exception("队列为空队");
}
Object obj=this.queue[front];
front=(front+1)%maxSize;
count--;
return obj;
}
@Override
public Object getFront() throws Exception {
// TODO Auto-generated method stub
if(!this.isEmpty()) {
return this.queue[front];
}
return null;
}
@Override
public boolean isEmpty() {
// TODO Auto-generated method stub
return this.count==0;
}
}
Class WindowQueue
public class WindowQueue { //卖票的窗口
//定义卖票队列
int maxSize=10;
MyQueue queue=new MyQueue(maxSize);
int num=0; //最多卖100张票
boolean flag=true ; //判断是否继续卖票
//排队买票
public synchronized void producer()throws Exception{
if(this.queue.count<maxSize) {
this.queue.append(num++); //等待买票的数量++
System.out.println("第"+num+"个客户排队买票");
this.notifyAll(); //唤醒等待的线程
}else {
System.out.println("队列已满 请等待");
this.wait();
}
}
//卖票
public synchronized void consumer()throws Exception{
if(this.queue.count>0) {
Object obj=this.queue.delete(); //出队
int temp=Integer.parseInt(obj.toString());
System.out.println("第"+(temp+1)+"个客户买到票离开队列");
//如果当前的队列为空 并且卖出票数大于100
if(this.queue.isEmpty()&&this.num>=100) {
this.flag=false;
}
this.notifyAll(); //唤醒等待的线程
}else {
System.out.println("队列已空 请等待");
this.wait();
}
}
}
Class Producer
public class Producer implements Runnable{
WindowQueue queue;
public Producer(WindowQueue queue) {
this.queue=queue;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(queue.num<100) { //必须小于100张票 才可以买票
try {
Thread.sleep(1000);
queue.producer();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
Class Consumer
public class Consumer implements Runnable{
WindowQueue queue;
public Consumer(WindowQueue queue) {
this.queue=queue;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(queue.flag) { //如果队列为空 并且票数大于100 就不会卖票了
try {
Thread.sleep(1000);
queue.consumer();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
Class QueueTest
public class QueueTest {
public static void main(String[] args) throws Exception {
WindowQueue queue=new WindowQueue();
Producer p=new Producer(queue);
Consumer con=new Consumer(queue);
//以上的代码一定要注意 传入的是同一个对象
Thread t1=new Thread(p);
Thread t2=new Thread(con);
t1.start();
t2.start();
}
}
Lambda表达式
-
Lambda表达式的形式
参数，箭头(→)以及一个表示
-
Lambda适用于接口中一个抽象方法时候使用
-
举例1——函数式接口使用
Runnable runner = ()->{ StringBuffer s = new StringBuffer(); for(int i= 0;i < 10;i++) System.out.println(s.append("haha")); }; -
举例2——只有一个抽象方法的接口的实现类的使用
Thread t1 = new Thread(()->{ StringBuffer s = new StringBuffer(); for(int i= 0;i < 10;i++) System.out.println(s.append("haha")); }); -
区别于匿名内部类——需要写出方法声明
new Thread(new Runnable() { public void run() { StringBuffer s = new StringBuffer(); for(int i= 0;i < 10;i++) System.out.println(s.append("haha")); } }).start(); Thread t1 = new Thread() { public void run() { StringBuffer s = new StringBuffer(); for(int i= 0;i < 10;i++) System.out.println(s.append("haha")); } };
扫一扫
167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
