程序-->进程-->线程
线程不一定立即执行，由CPU安排调度
//创建线程的方法 1 继承thread类 重写run方法
public class TestThead extends Thread {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println("我是创建的线程--->"+i);
}
}
public static void main(String[] args) {
TestThead threadtest1 = new TestThead();
threadtest1.start();
for (int i = 0; i < 1000; i++) {
System.out.println("我是主线程---->"+i);
}
}
}
创建线程的方法二
public class TestThread3 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
System.out.println("我是创建的线程--->"+i);
}
}
public static void main(String[] args) {
TestThread3 threadtest3 = new TestThread3(); //创建一个实现runnable接口的实现类对象，将此对象放入Thread对象中
new Thread(threadtest3).start();
for (int i = 0; i < 1000; i++) {
System.out.println("我是主线程---->"+i);
}
}
}
实现runnable接口的好处:
创建线程的三种方式：1.继承Thread类 2.实现runnable接口 3. 实现callable接口
public class TestLamda {
//2.创建静态内部类
static class Like2 implements Ilike{
@Override
public void lamda() {
System.out.println("我喜欢lamDa2.0");
}
}
public static void main(String[] args) {
Ilike l = new Like();
l.lamda();
l = new Like2();
l.lamda();
//3.创建局部内部类
class Like3 implements Ilike{
@Override
public void lamda() {
System.out.println("我喜欢lamDa3.0");
}
}
l = new Like3();
l.lamda();
//4.匿名内部类
l = new Ilike(){
@Override
public void lamda() {
System.out.println("我喜欢lamDa4.0");
}
};
l.lamda();
//5.用lamda简化
l =()-> {
System.out.println("我喜欢lamDa5.0");
};
l.lamda();
}
}
//1. 函数式接口
interface Ilike{
void lamda();
}
class Like implements Ilike{
@Override
public void lamda() {
System.out.println("我喜欢lamDa1.0");
}
}
总结:
lambda表达式只能有一行代码的情况 下才能简化成为-一行，如果有多行，那么就用代码块包裹。
前提是接口为函数式接口
多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号.
public class TestLamda2 {
public static void main(String[] args) {
Ilove love = (a)->{ //可以省略int 一个参数的时候可以省略括号
System.out.println("I love "+a);
};
love.love(520);
}
}
interface Ilove{
void love(int a);
}
静态代理模式总结: .
真实对象利代理对象都要实现同一个接口
代理对象要代理真实角色
好处:
public class TestYield {
public static void main(String[] args) {
MyYield t = new MyYield();
new Thread(t,"a").start();
new Thread(t,"b").start();
}
}
//线程的礼让不一定成功，看CPU调度
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始执行！");
Thread.yield();
System.out.println(Thread.currentThread().getName()+"线程结束执行！");
}
}
由于同一个进程的多个线程共享同一块存储空间,在带来方便的同时，也带来了访问
冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制
synchronized ,当-个线程获得对象的排它锁,独占资源,其他线程必须等待,
使用后释放锁即可.存在以下问题:
public class TestThread5 {
public static void main(String[] args) {
buyTicket buy = new buyTicket();
new Thread(buy,"高帅").start();
new Thread(buy,"田永平").start();
new Thread(buy,"蔡鹏瑞").start();
}
}
class buyTicket implements Runnable{
private int ticketNum = 10;
boolean flag = true; //外部停止方法
@Override
public void run() {
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void buy() throws InterruptedException {
if(ticketNum<=0){
flag = false;
return;
}
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"买了第"+ticketNum--+"张票");
}
}
运行结果:
蔡鹏瑞买了第10张票
田永平买了第9张票
高帅买了第10张票
高帅买了第8张票
蔡鹏瑞买了第8张票
田永平买了第7张票
高帅买了第4张票
田永平买了第5张票
蔡鹏瑞买了第6张票
田永平买了第3张票
高帅买了第2张票
蔡鹏瑞买了第3张票
蔡鹏瑞买了第-1张票
田永平买了第1张票
高帅买了第0张票
进程已结束，退出代码 0
public synchronized void buy() throws InterruptedException {
if(ticketNum<=0){
flag = false;
return;
}
Thread.sleep(500);
System.out.println(Thread.currentThread().getName()+"买了第"+ticketNum--+"张票");
}
给buy方法上锁。
同步块: synchronized (Obj){ }
Obj称之为同步监视器
Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this ,就是
这个对象本身,或者是class [反射中讲解]
同步监视器的执行过程
产生死锁的四个必要条件:
class buyTicket implements Runnable {
private int ticketNum = 10;
boolean flag = true; //外部停止方法
private final ReentrantLock lock = new ReentrantLock(); //定义lock锁
@Override
public void run() {
while (flag) {
try {
lock.lock();
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
public void buy() throws InterruptedException {
if (ticketNum <= 0) {
flag = false;
return;
}
Thread.sleep(500);
System.out.println(Thread.currentThread().getName() + "买了第" + ticketNum-- + "张票");
}
}
public class TestPC {
public static void main(String[] args) {
Buffer buffer = new Buffer();
new Productor(buffer).start();
new Consumer(buffer).start();
}
}
//生产者
class Productor extends Thread{
Buffer buffer = new Buffer();
public Productor(Buffer buffer) {
this.buffer = buffer;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("生产了第"+i+1+"只鸡");
buffer.push(new Chicken(i));
}
}
}
class Consumer extends Thread{
Buffer buffer = new Buffer();
public Consumer(Buffer buffer) {
this.buffer = buffer;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("消费了第"+buffer.pop().id+"只鸡");
}
}
}
class Chicken{
int id;
public Chicken(int id) {
this.id = id;
}
}
class Buffer{
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.notifyAll();
}
public synchronized Chicken pop(){
if(count==0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
count--; //个数 不是下标 所以得先减去1
Chicken chicken = chickens[count];
//通知生产者生产
this.notifyAll();
return chicken;
}
}
原文：https://www.cnblogs.com/g414056667/p/15252965.html