> ```
> PrimeRun p = new PrimeRun(143);
> new Thread(p).start();
> ```
### **方式一**
```java
//创建线程方式一:继承Thread类,重写run()方法,调用start开启线程
public class One extends Thread{
@Override
public void run(){
//run方法线程体
for (int i = 0; i < 10; i++) {
System.out.println("数字---" + i);
}
}
public static void main(String[] args) {
//main线程,主线程
//创建一个线程对象
One one = new One();
//调用start()方法开启线程
one.start();
for (int i = 0; i < 1000; i++) {
System.out.println("线程---" + i);
}
}
}
```
### **方式二**
```java
//创建线程方式二:实现runnable接口,重写run方法,执行线程需要丢入runnable接口实现类,调用start方法。
public class Two implements Runnable{
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 100; i++) {
System.out.println("数字---" + i);
}
}
public static void main(String[] args) {
//创建runnable接口的实现类对象
Two two = new Two();
//创建线程对象,通过线程对象来开启我们的线程,代理
// Thread thread = new Thread(two);
// thread.start();
new Thread(two).start();
for (int i = 0; i < 100; i++) {
System.out.println("线程--" + i);
}
}
}
```
## 并发任务
初识并发:
```java
public class Ticket 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();
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
```
## 静态代理模式
```java
public class StaticType {
public static void main(String[] args) {
WedingCompany wedingCompany = new WedingCompany(new You());
wedingCompany.HappyMarry();
}
}
interface Marry{
void HappyMarry();
}
//真实对象,你去结婚
class You implements Marry{
@Override
public void HappyMarry() {
System.out.println("结婚了,超级开心!");
}
}
//代理角色,帮助你结婚
class WedingCompany implements Marry{
private Marry target; //代理谁-->真实目标
public WedingCompany(Marry target){
this.target = target;
}
@Override
public void HappyMarry() {
before();
this.target.HappyMarry();
after();
}
```java
/*
推导Lambda表达式
*/
public class ClassLambda {
//3.静态内部类
static class Like2 implements ILike {
@Override
public void lambda() {
System.out.println("I like lambda2!");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
//4.局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda3!");
}
}
like = new Like3();
like.lambda();
//5.匿名内部类,没有类的名称,必须借助接口或者父类
like = new ILike() {
@Override
public void lambda() {
System.out.println("I like lambda4!");
}
};
like.lambda();
//6.用lambda简化
like = ()->{
System.out.println("I like lambda5!");
};
like.lambda();
}
}
//1.定义一个函数式接口
interface ILike{
void lambda();
}
//2.实现类
class Like implements ILike {
@Override
public void lambda() {
System.out.println("I like lambda!");
}
}
```
**简化Lambda**
```java
public class TestLambda {
public static void main(String[] args) {
//lambda表示简化
Ilove ilove = (int a) -> {
System.out.println("I love you!" + a);
};
//简化1.参数类型
ilove = (a) -> {
System.out.println("1.I love you!" + a);
};
//简化2.简化括号
ilove = a -> {
System.out.println("2.I love you!" + a);
};
//简化3.简化花括号
ilove = a -> System.out.println("3.I love you!" + a);
ilove.love(520);
}
}
interface Ilove{
void love(int a);
}
```
总结:
- lambda表达式只能有一行代码的情况下才能简化成为一行,如果有多行,那么就用代码块包裹。
- 前提是接口时函数式接口。
- 多个参数也可以去掉参数类型,要去掉都去掉,必须加上括号。
## Stop方法:线程停止
```java
//测试stop
//1.建议线程正常停止--->利用次数,不建议死循环
//2.建议使用标志位--->设置一个标志位
//3.不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class TestStop implements Runnable {
//1.设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("run Thread..." + i++);
}
}
//2.设置一个公开的方法停止线程,转换标志位
public void stop(){
this.flag = false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 100; i++) {
System.out.println("main" + i);
if (i == 90){
//调用stop方法切换标志位,让线程停止
testStop.stop();
System.out.println("线程该停止了。");
}
}
}
public static void Down() throws InterruptedException {
int number = 10;
while (true) {
Thread.sleep(1000);
System.out.println(number--);
if (number <= 0)
break;
}
}
}
```
```java
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() + "-->start");
Thread.yield();
System.out.println(Thread.currentThread().getName() + "-->end");
}
}
```
## Join方法:线程强制执行
- Join合并线程,待线程执行完成后,在执行其他线程,其他线程阻塞
- 不建议使用,容易导致进程阻塞
```java
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("VIP插队" + i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
//主线程
for (int i = 0; i < 100; i++) {
if (i == 10){
thread.join();
}
System.out.println("main" + i);
}
}
}
```
public class TestLock {
public static void main(String[] args) {
wantTicket buy = new wantTicket();
new Thread(buy,"a").start();
new Thread(buy,"b").start();
new Thread(buy,"c").start();
}
}
class wantTicket implements Runnable{
int TicketNum = 10;
private final ReentrantLock lock = new ReentrantLock();
//生产者,消费者,产品,缓冲区
public class TestPC {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Productor(container).start();
new Consumer(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 Consumer extends Thread{
SynContainer container;
public Consumer(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;
```java
//测试生产者消费者问题2-->信号灯法,标志位解决
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 {
//演员表演,观众等待 T
//观众观看,演员等待 F
String voice; //表演的节目
boolean flag = true;