2、创建代理角色 Thread+引用
3、代理角色.start()
/**
-
使用Runable 创建 线程
-
1、类实现Runable接口 +重写run() 真实角色类
-
2、启动多线程 使用静态代理
-
1)创建真实角色
-
2)创建代理角色+真实角色引用
-
3)调用.start()
-
@author lyy
*/
public class Programer implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(“一边敲代码。。。。。”);
}
}
public static void main(String[] args) {
// 1)创建真实角色
Programer pro = new Programer();
// 2)创建代理角色+真实角色引用
Thread proxy = new Thread(pro);
// 3)调用.start()
proxy.start();
for (int i = 0; i < 1000; i++) {
System.out.println(“一边聊QQ。。。。。”);
}
}
}
1.3 实现Callable(了解)
通过Callable接口实现多线程
优点:可以获取返回值
package com.org.pc;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
-
使用Callable创建线程
-
@author lyy
*/
public class Call {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建线程
ExecutorService ser = Executors.newFixedThreadPool(2);
Race tor = new Race(“千年王八”,1000);
Race rabbit = new Race(“小兔子”,500);
//获取值
Future result1 = ser.submit(tor);
Future result2 = ser.submit(rabbit);
Thread.sleep(2000);//休眠2秒
tor.setFlag(false);//停止线程体中的循环
rabbit.setFlag(false);//停止线程体中的循环
int num1 = result1.get();
int num2 = result2.get();
System.out.println(“大乌龟跑了----->”+num1+“步”);
System.out.println(“小兔子跑了----->”+num2+“步”);
//停止服务
ser.shutdown();
}
}
class Race implements Callable{
private String name;//名称
private long time;//延时时间
private boolean flag = true;
private int step = 0;//步数
public Race(){
}
public Race(String name) {
super();
this.name = name;
}
public Race(String name, int time) {
super();
this.name = name;
this.time = time;
}
@Override
public Integer call() throws Exception {
while(flag){
Thread.sleep(time);//延时
step++;
}
return step;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public long getTime() {
return time;
}
public void setTime(long time) {
this.time = time;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
public int getStep() {
return step;
}
public void setStep(int step) {
this.step = step;
}
}
三:线程运行示意图
新生–>就绪–>运行–>阻塞–>终止
四:线程的终止(重点)
1、自然终止:线程体正常执行完毕
2、外部干涉
1)线程类中 定义 线程体使用的标识
2)线程提供使用该标识
3) 对外提供方法改变该标识
4) 外部根据条件调用该方法
package com.org.status;
public class StopDemo1 {
public static void main(String[] args) {
Study stu = new Study();
new Thread(stu).start();
//外部改变该标识
for (int i = 0; i < 100; i++) {
if(i==50){//外部干涉
stu.stop();
}
System.out.println(“main…”+i);
}
}
}
class Study implements Runnable{
//1)线程类中 定义 线程体使用的标识
private boolean flag =true;
@Override
public void run() {
//2)线程提使用该标识
while(flag){
System.out.println(“Study thread …”);
}
}
//3)、对外提供方法改变该标识
public void stop(){
this.flag = false;
}
}
五:阻塞
IsAlive() 判断线程是否还活着,既线程是还未终止
getPriority()获得线程的优先级数值
setPriority() 设置线程的优先级数值
setName()给线程一个名字
getName()取得线程的名字
currentThread()取得当前正在运行的线程对象也就是取得自己本身
阻塞:join yield sleep(重点)
1、Join:合并线程
package com.org.status;
/**
-
join:合并线程
-
@author lyy
*/
public class JoinDemo01 extends Thread {
public static void main(String[] args) throws InterruptedException {
JoinDemo01 join = new JoinDemo01();
Thread t = new Thread(join);//新增
t.start();//就绪
//cpu调度运行
for (int i = 0; i < 100; i++) {
if(50 == i){
t.join();//main阻塞
}
System.out.println(“main…”+i);
}
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(“join…”+i);
}
}
}
2、Yield:暂停自己的线程
package com.org.status;
import javax.sound.midi.Synthesizer;
public class YieldDemo01 extends Thread{
public static void main(String[] args) {
YieldDemo01 yield = new YieldDemo01();
Thread t = new Thread(yield);//新生
t.start();//就绪
//cpu调度运行
for (int i = 0; i < 100; i++) {
if(i%20 == 0){
//暂停本线程main
Thread.yield();
}
System.out.println(“main…”+i);
}
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(“yield…”+i);
}
}
}
3、Sleep():休眠,不释放锁
1)、时间相关(倒计时)
package com.org.status;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
-
倒计时
-
1、倒数10个数,一秒内打印一个
-
2、倒计时
-
@author lyy
*/
public class SleepDemo01 {
public static void main(String[] args) throws InterruptedException {
Date endTime = new Date(System.currentTimeMillis() + 10*1000);
long end = endTime.getTime();
while(true){
//输出
System.out.println(new SimpleDateFormat(“mm:ss”).format(endTime));
//构建下一秒的时间
endTime = new Date(endTime.getTime() - 1000);
//等待一秒时间
Thread.sleep(1000);
//如果在十秒以内继续否则退出
if(end -10000 > endTime.getTime()){
System.out.println(“ending”);
break;
}
}
}
public static void test1() throws InterruptedException{
int num = 10;
while(true){
System.out.println(num–);
Thread.sleep(1000);//暂停
if(num <= 0){
break;
}
}
}
}
2)、模拟网络延时
package com.org.status;
/**
-
Sleep模拟 网络延时 线程不安全的
-
@author lyy
*/
public class SLeepDemo02 {
public static void main(String[] args) {
//真实角色
Web12306 web = new Web12306();
//代理角色
Thread t1 = new Thread(web,“工程师”);
Thread t2 = new Thread(web,“黄牛已”);
Thread t3 = new Thread(web,“路人甲”);
//启动线程
t1.start();
t2.start();
t3.start();
}
}
class Web12306 implements Runnable{
private int num = 80;
@Override
public void run() {
while(true){
if(num <= 0){
break;//跳出循环
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+“抢到了”+num–);
}
}
}
同步:并发多个线程访问同一份资源确保资源安全 ==> 线程安全
Synchronized --> 同步
一、同步块
Synchronized(引用类型|this|类.class){
}
package com.org.syn;
public class SynDemo01 {
public static void main(String[] args) {
//真实角色
Web123 web = new Web123();
//代理角色
Thread t1 = new Thread(web,“工程师”);
Thread t2 = new Thread(web,“黄牛已”);
Thread t3 = new Thread(web,“路人甲”);
//启动线程
t1.start();
t2.start();
t3.start();
}
}
class Web123 implements Runnable{
private int num = 10;
private boolean flag = true;
@Override
public void run() {
while(flag){
test3();
}
}
//线程不安全 锁定资源不正确
public void test6(){
//a b c
if(num <= 0){
flag =false;//跳出循环
return;
}
synchronized (this) {
try {
Thread.sleep(500);//模拟 延时
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+“抢到了”+num–);
}
}
//线程不安全 锁定资源不正确
public void test5(){
//a b c
synchronized ((Integer)num) {
if(num <= 0){
flag =false;//跳出循环
return;
}
try {
Thread.sleep(500);//模拟 延时
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+“抢到了”+num–);
}
}
//锁定范围不正确
public void test4(){
//a b c
synchronized (this) {
if(num <= 0){
flag =false;//跳出循环
return;
}
try {
Thread.sleep(500);//模拟 延时
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+“抢到了”+num–);
}
}
//线程安全,锁定正确
public void test3(){
//a b c
synchronized (this) {
if(num <= 0){
flag =false;//跳出循环
return;
}
try {
Thread.sleep(500);//模拟 延时
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+“抢到了”+num–);
}
}
public synchronized void test2(){
if(num <= 0){
flag =false;//跳出循环
return;
}
try {
Thread.sleep(500);//模拟 延时
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+“抢到了”+num–);
}
//线程不安全
public void test1(){
if(num <= 0){
flag =false;//跳出循环
return;
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+“抢到了”+num–);
}
}
二、同步方法
Synchronized
线程安全的效率慢,保证资源的正确
线程不安全的效率快
三、死锁:过多的同步容易造成死锁
package com.org.syn;
/**
-
过多的方法可能造成死锁
-
@author lyy
*/
public class SncDemo3 {
public static void main(String[] args) {
Object g = new Object();
Object m = new Object();
Test t1 = new Test(g,m);
Test t2 = new Test(g,m);
Thread proxy1 = new Thread(t1);
Thread proxy2 = new Thread(t2);
proxy1.start();
proxy2.start();
}
}
class Test implements Runnable{
Object goods;
Object money;
public Test(Object goods, Object money) {
this.goods = goods;
this.money = money;
}
@Override
public void run() {
while(true){
test();
}
}
public void test(){
synchronized (goods) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized (money) {
// System.out.println(“一手给货”);
}
}
}
class test2 implements Runnable{
Object goods;
Object money;
public test2(Object goods, Object money) {
this.goods = goods;
this.money = money;
}
@Override
public void run() {
while(true){
test();
}
}
public void test(){
synchronized (money) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
synchronized (goods) {
System.out.println(“一手给货”);
}
}
}
解决方法:生产者消费者模式
先生产,在消费
package com.org.pro;
/**
-
一个场景,一个共同的资源
-
生产者和消费者模式信号灯法
-
wait() 等待 释放锁 sleep 不释放锁
-
notify()/notifyAll() 唤醒
-
与 synchronized
-
@author lyy
*/
public class Movie {
private String pic;
//信号灯
//flag --> T 生产者生产 消费者消费 生产完成后 通知消费
//flag --> f 消费者消费 生产者等待 消费完成后唤醒生产
private boolean flag = true;
public synchronized void play(String pic){
if(!flag){//生产者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//开始生产
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(“生产了:”+pic);
//生产完毕
this.pic = pic;