多线程学习
多线程
1.创建线程
Thread class（重点）,Runnable接口（重点），Callable接口（了解）
2.继承Thread类
package ThreadText;
//创建线程方式1：继承Thread类，重写run()方法，调用start开启线程
public class TextThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
//run方法线程体
System.out.println("我在看代码"+i);
}
}
public static void main(String[] args){
//main线程，主线程
//创建一个线程对象
TextThread1 textThread1=new TextThread1();
//调用start()方法开启线程
textThread1.start();
for(int i=1;i<20;i++){
System.out.println("我在学习多线程"+i);
}
}
}
注：线程开启不一定立即执行，由cpu调度执行
网图下载
package ThreadText;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class TextThread2 extends Thread{
private String url;//网络图片地址
private String name; //保存的文件名
public TextThread2(String url ,String name){
this.name=name;
this.url=url;
}
//下载图片线程执行体
@Override
public void run(){
WebDownLoader webDownLoader=new WebDownLoader();
webDownLoader.downloader(url,name);
System.out.println("下载了文件名为："+name);
}
public static void main(String[] args){
TextThread2 t2=new TextThread2("https://cn.bing.com/images/search?view=detailV2&ccid=QoyRTAJQ&id=0B88A36BD2ABEB5161368D4D7ACB4E30D12C8FAE&thid=OIP.QoyRTAJQNvvIcxxx1lr7jQHaE8&mediaurl=https%3a%2f%2fts1.cn.mm.bing.net%2fth%2fid%2fR-C.428c914c025036fbc8731c71d65afb8d%3frik%3dro8s0TBOy3pNjQ%26riu%3dhttp%253a%252f%252fimg1.gtimg.com%252ftech%252fpics%252fhv1%252f186%252f10%252f1883%252f122444811.jpg%26ehk%3dcNrGPHJr0jenOBAeWhBSVbhbsjxMNaWBLQ1md4Dtb0g%253d%26risl%3d%26pid%3dImgRaw%26r%3d0&exph=427&expw=640&q=%e8%b6%85%e6%98%9f%e5%9b%be%e7%89%87&simid=608046006702729835&FORM=IRPRST&ck=FE69DB6AFC46E2C1F0161F8E68DFEEFD&selectedIndex=0&idpp=overlayview&ajaxhist=0&ajaxserp=0","11");
TextThread2 t3=new TextThread2("https://cn.bing.com/images/search?view=detailV2&ccid=AoJfpBZL&id=D3C433F0BB648C694DC0D373BD4C6A58CA5BA2EC&thid=OIP.AoJfpBZLJgu7MDnPuXi7uQHaC9&mediaurl=https%3a%2f%2fyun-campus-res.oss-cn-shenzhen.aliyuncs.com%2fcompany%2f1575974430-9685.png&exph=233&expw=582&q=%e8%b6%85%e6%98%9f%e5%9b%be%e7%89%87&simid=608005273237218358&FORM=IRPRST&ck=3019D57A5D64C77EFF2BB2EB15ECCF75&selectedIndex=8&ajaxhist=0&ajaxserp=0","12");
TextThread2 t4=new TextThread2("https://cn.bing.com/images/search?view=detailV2&ccid=p%2bm8y5Ve&id=80F95888ED6A284692719690C312C8D363B49AB1&thid=OIP.p-m8y5VeQ-23IZHsLLCmxQAAAA&mediaurl=https%3a%2f%2fts1.cn.mm.bing.net%2fth%2fid%2fR-C.a7e9bccb955e43edb72191ec2cb0a6c5%3frik%3dsZq0Y9PIEsOQlg%26riu%3dhttp%253a%252f%252fpic.2265.com%252fupload%252f2017-3%252f2017371121568859.png%26ehk%3d5rIDojxLf6pPLdQC9zIPp27LJ0lz6vp7VOlMJd0a8hk%253d%26risl%3d%26pid%3dImgRaw%26r%3d0&exph=256&expw=256&q=%e8%b6%85%e6%98%9f%e5%9b%be%e7%89%87&simid=608036008020825358&FORM=IRPRST&ck=74D8460CB61358CD53FF877300FC6FED&selectedIndex=0&idpp=overlayview&ajaxhist=0&ajaxserp=0","13");
t2.start();
t3.start();
t4.start();
}
}
//下载器
class WebDownLoader{
//下载方法
public void downloader(String url ,String name){
try{
FileUtils.copyURLToFile(new URL(url),new File(name));
}catch (IOException e){
e.printStackTrace();
System.out.println("IO异常，downloader方法出现问题");
}
}
}3.实现Runnable(推荐使用)
package ThreadText;
//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢人runnable接口实现类，调用start方法
public class TestThread3 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
//run方法线程体
System.out.println("我在看代码"+i);
}
}
public static void main(String[] args){
//创建一个runnable接口的实现类对象
TestThread3 testThread3=new TestThread3();
//创建线程对象，通过线程对象来开启我们的线程，代理
//Thread thread=new Thread();
//thread.start();
new Thread(testThread3).start();
for(int i=1;i<20;i++){
System.out.println("我在学习多线程"+i);
}
}
}4.初始并发问题
package ThreadText;
//多个线程同时操作同个对象
//买火车票的例子,发现问题，多个线程同时操作同个对象数据紊乱
public class TestThread4 implements Runnable{
//票数
private int tickNums=10;
@Override
public void run(){
while(true){
if(tickNums<=0){
break;
}
//模拟延时
try{
Thread.sleep(200);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"拿到第"+tickNums--+"票");
}
}
public static void main(String[] args) {
TestThread4 ticket=new TestThread4();
new Thread(ticket,"明").start();
new Thread(ticket,"红").start();
new Thread(ticket,"华").start();
}
}5.静态代理
package ThreadText;
//真实对象与代理对象实现同一接口，代理对象要代理真实对象
public class StaticProxy {
public static void main(String[] args) {
new Thread(()->System.out.println("嘻嘻")).start();
new WeddingCompany(new You()).HappyMarry();
//WeddingCompany weddingCompany=new WeddingCompany(new You());
//weddingCompany.HappyMarry();
}
}
interface Marry{
void HappyMarry();
}
//真实角色
class You implements Marry{
@Override
public void HappyMarry(){
System.out.println("小明结婚");
}
}
//代理角色
class WeddingCompany implements Marry{
//代理真实目标角色
private Marry target;
public WeddingCompany(Marry target){
this.target=target;
}
@Override
public void HappyMarry(){
before();
this.target.HappyMarry(); //这就是真实对象
after();
}
private void after() {
System.out.println("后，收款");
}
private void before() {
System.out.println("前，布置现场");
}
}
6.线程状态
线程停止
线程休眠：
1.模拟网络延时：放大问题的发生性
2.模拟延时
package ThreadText;
//模拟倒计时
package ThreadText;
import javax.xml.crypto.Data;
import java.text.SimpleDateFormat;
import java.util.Date;
import static java.lang.System.currentTimeMillis;
//模拟倒计时
public class TestSleep {
public static void main(String[] args) {
/* 打印当前系统时间 */
Date startTime = new Date(currentTimeMillis());
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime=new Date(currentTimeMillis());
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
public static void tenDown()throws InterruptedException {
int num=10;
while(true){
Thread.sleep(1000);
System.out.println(num--);
if(num<=0){
break;
}
}
}
}线程礼让
package ThreadText;
public class TestYield {
public static void main(String[] args) {
MyYield myYield=new MyYield();
new Thread (myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+"线程开始");
Thread.yield();
System.out.println(Thread.currentThread().getName()+"线程停止");
}
}
线程强制执行
线程的优先级
package ThreadText;
//测试线程的优先级
public class TestPriority {
public static void main(String[] args) {
//主线程默认优先级 5
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
Mypriority mypriority=new Mypriority();
Thread t1=new Thread(mypriority);
Thread t2=new Thread(mypriority);
Thread t3=new Thread(mypriority);
Thread t4=new Thread(mypriority);
Thread t5=new Thread(mypriority);
Thread t6=new Thread(mypriority);
//设置优先级
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY为10
//t5.setPriority(-1); //小于1，大于10报错
//t5.start();
//t6.setPriority(11);
//t6.start();
}
}
class Mypriority implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}线程强制执行
线程的优先级
package ThreadText;
//测试线程的优先级
public class TestPriority {
public static void main(String[] args) {
//主线程默认优先级 5
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
Mypriority mypriority=new Mypriority();
Thread t1=new Thread(mypriority);
Thread t2=new Thread(mypriority);
Thread t3=new Thread(mypriority);
Thread t4=new Thread(mypriority);
Thread t5=new Thread(mypriority);
Thread t6=new Thread(mypriority);
//设置优先级
t1.start();
t2.setPriority(1);
t2.start();
t3.setPriority(4);
t3.start();
t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY为10
//t5.setPriority(-1); //小于1，大于10报错
//t5.start();
//t6.setPriority(11);
//t6.start();
}
}
class Mypriority implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}守护线程
7.线程同步机制
线程同步其实就是一种解决机制，多个需要访问此对象的线程进入这个对象等待池形成队列，等待前面线程使用完毕，下一个线程在使用
不安全样例：买票，取钱
锁机制
同步方法
注：synchronized的默认锁是this,锁的对象应该是变化的对象，即需要增删改的对象
lock锁
package ThreadText;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2=new TestLock2();
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable{
int tickNums=10;
//定义lock锁
private final ReentrantLock lock=new ReentrantLock();
@Override
public void run(){
while(true){
try {
lock.lock();//加锁
if (tickNums > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tickNums--);
} else {
break;
}
}finally {
//解锁
lock.unlock();
}
}
}
}
8. CopyOnWriteArrayList
安全的集合
package ThreadText;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
public class TestJUC {
public static void main(String[] args) {
CopyOnWriteArrayList list=new CopyOnWriteArrayList();
for (int i = 0; i < 10000; i++) {
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
9.线程协作
生产者消费者问题
管程法
package ThreadText;
//管程法
public class TestPC {
public static void main(String[] args) {
SynContainer container=new SynContainer();
new Productor(container).start();
new Consummer(container).start();
}
}
//生产者
class Productor extends Thread{
SynContainer container;
public Productor(SynContainer container) {
this.container = container;
}
//生产
@Override
public void run(){
for (int i = 0; i < 100; i++) {
container.push(new Chicken(i));
System.out.println("生产了"+i+"只鸡");
}
}
}
//消费者
class Consummer extends Thread{
SynContainer container;
public Consummer(SynContainer container) {
this.container = container;
}
//消费
@Override
public void run(){
for (int i = 0; i < 100; i++) {
System.out.println("消费了-->"+container.pop().id+"只鸡");
}
}
}
//产品
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.notify();
}
public synchronized Chicken pop(){
if(count==0){
//等待生产者生产
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count--;
Chicken chicken=chickens[count];
//吃完，通知消费者生产
this.notify();
return chicken;
}
}信号灯法
package ThreadText;
//信号灯法，标志位解决
public class TestPc2 {
public static void main(String[] args) {
TV tv=new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
//生产者：演员
class Player extends Thread{
TV tv;
public Player(TV tv) {
this.tv = tv;
}
@Override
public void run(){
for (int i = 0; i < 20; i++) {
if(i%2==0){
this.tv.play("节目");
}else {
this.tv.play("广告");
}
}
}
}
//消费者： 观众
class Watcher extends Thread{
TV tv;
public Watcher(TV tv) {
this.tv = tv;
}
@Override
public void run(){
for (int i = 0; i < 20; i++) {
tv.watch();
}
}
}
class TV{
//演员表演，观众等待
//观众观看，演员等待
String voice;//表演的节目
boolean flag=true;
public synchronized void play(String voice){
if(!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("演员表演了："+voice);
//通知观众观看
this.notifyAll();//唤醒
this.voice=voice;
this.flag=!this.flag;
}
//观看
public synchronized void watch(){
if(flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观看了"+voice);
//汤汁演员表演
this.notifyAll();
this.flag=!this.flag;
}
}10.线程池
