多线程中的问题及解决
一般的线程中会遇到一些安全问题，那么如何解决？校验一个多线程程序是否有安全问题的隐患的前提条件:
* 1)当前程序是否是多线程环境
* 2)是否有共享数据
* 3)是否有多条语句对共享数据进行操作
* 看当前案例是否有多线程的安全问题:
* 1)是否是多线程环境 是
* 2)是否有共享数据 是
* 3)是否有多条语句对共享数据进行操作 是
* 1)多线程环境 不能解决
* 2)对共享数据进行优化 不能解决
* 3)解决将多条语句对共享数据这一环进行解决
*
* 解决方案:就是将多条语句对共享数据操作的代码,用一个代码包起来---->代码--->同步代码块
格式:
* synchronized(锁对象){* 针对多条语句对共享数据操作代码;
* }
*
* 锁对象:肯定一个对象,随便创建一个对象(匿名对象)
* 给刚才的这个程序加入了同步代码块,但是锁对象使用的匿名对象(每一个线程进来都有自己的锁),还是没有解决!
*
锁对象:每一个线程最总使用的锁对象,只能是同一把锁 这是一定需要注意的
同步代码块举例：* 火车上上厕所(锁对象:将它看成是门的开和关)
*
* synchronized(锁对象){
* 多条语句对共享数据操作的代码;
* }
*
注意:
* 锁对象:一定要同一个锁(每个线程只能使用同一把锁)
* 锁对象:任何的Java类(引用类型)
两种线程同步方法：
如果一个方法的定义一开始就是同步代码块，那么可以将此方法用synchronized来修饰，该方法为非静态同步方法。非静态的方法:同步方法(需要底层源码,一些方法会声明synchronized)的锁对象:this
静态的同步方法:和反射有关 (静态同步方法的锁对象:类名.class)
public static <T> List<T> synchronizedList(List<T> list)
返回指定列表支持的同步（线程安全的）列表
List list = Collections.synchronizedList(array) 线程安全的方法
Jdk5.0以后,java提供了一个具体的锁: Lock接口
private Lock lock= new ReentrantLock();
显式获取锁的前提,一定要创建Lock接口对象，最后一定要释放锁
//try...finallylock.lock(); //获取锁 类似于syncrhonized(obj) if (条件) { try {
Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } }
//释放锁
上述方法虽然解决了多线程安全问题,但是还是有些问题:
1)执行效率低
2)会产生死锁
死锁：两个或两个以上的线程,在执行的过程中出现互相等待的情况
等待唤醒机制：
synchronized(锁对象){
相关条件下{
相关操作
锁对象.wait(); 立即释放锁
}
别的情况下{
相关操作
锁对象.notify; 作用是唤醒当前的wait()线程
}
}
线程组和线程池
* 程组表示一个线程的集合。此外，线程组也可以包含其他线程组* 线程池(某个线程执行完毕,反复利用线程对象)
public static void main(String[] args) {
//获取线程组的名称
method1();
//如何给多个线程设置一个线程组名称呢?
method2();
}
private static void method2() {
// public ThreadGroup(String name) 构造一个新线程组
ThreadGroup tg = new ThreadGroup("main-新的线程组") ;
MyThread my = new MyThread() ;
// Thread(ThreadGroup group, Runnable target, String name)
Thread t1 = new Thread(tg, my, "线程1") ;
Thread t2 = new Thread(tg, my, "线程2") ;
//直接获取线程组名称
System.out.println(t1.getThreadGroup().getName());
System.out.println(t2.getThreadGroup().getName());
}
private static void method1() {
MyThread my = new MyThread() ;
//创建线程类对象
Thread t1 = new Thread(my, "线程1") ;
Thread t2 = new Thread(my, "线程2") ;
//public final ThreadGroup getThreadGroup()返回该线程所属的线程组
ThreadGroup tg1 = t1.getThreadGroup() ;
ThreadGroup tg2 = t2.getThreadGroup() ;
//public final String getName():返回线程组的名称
System.out.println(tg1.getName()); //main
System.out.println(tg2.getName());//main
//所有的线程它默认的线程组名称:main(主线程)
System.out.println(Thread.currentThread().getThreadGroup().getName());//main
}线程池 :多个线程执行完毕,它会重新回到线程池中,等待被利用,不会变成垃圾!
线程池有关的类
* 类 Executors: 一种工厂类
*
* 方法:
* 和线程池的创建有关系
* public static ExecutorService newFixedThreadPool(int nThreads)
* 创建一个可重用固定线程数的线程
* ExecutorService:可以执行异步任务
* 线程池调用完毕可以关闭的
* void shutdown():关闭之前,会提交刚才的任务
public static void main(String[] args) {
//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//提交和Runnable接口的方法或者Callable(提交任务)
pool.submit(new MyRunnable());
pool.submit( new MyRunnable()) ;
//pool-1-thread-2 :线程池-池数-线程类对象的描述-编号(从1开始)
//关闭线程池
pool.shutdown();
}* 创建一个线程池,执行接口中的方法
* 提交:Future<?> submit(Runnable task)
* <T> Future<T> submit(Callable<T> task)提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future
* Future:接口
* Future 表示异步计算的结果
Future接口实例：
public static void main(String[] args) throws Exception, ExecutionException {
ExecutorService pool = Executors.newFixedThreadPool(2);
Future<Integer> f1 = pool.submit(new MyCallable1(100));
Future<Integer> f2 = pool.submit(new MyCallable1(200));
//V get():获取结果 //使用该方法时注意抛出异常
Integer i1 = f1.get();
Integer i2 = f2.get();
System.out.println(i1);
System.out.println(i2);
//关闭线程池
pool.shutdown();
}
Java设计原则和设计模式
设计原则:
1: 单一职责原则:低耦合,高内聚
耦合性:类与类之间产生的关系
低耦合:让类与类之间的关系不复杂
内聚:执行一个件事情(功能)的能力
高内聚:一个类能够完成的事情,不要使用多个类一起来执行!
数据库
对某个数据进行增删改查(查询很重要的)
定一个接口: { 增(); 删(); 改(); 查(); }
实现类:
业务逻辑层:
增() {
具体实现
}
2: 开闭原则
核心思想是：一个对象对扩展开放，对修改关闭
开发好一个程序(项目),尽量不要修改原有代码
类和类之间假设有关系
更改一个类的功能,其他类已需要更改(增加代码的代码的书写量)
SVN(版本控制)/git
设计模式:
创建型模式 对象的创建
结构型模式 对象的组成(结构)
行为型模式 对象的行为
简单工厂模式--->静态工厂方法模式
* 设计一个工厂类:
* 工厂类提供一些静态方法,间接的去创建具体的对象
*
* 优点: 不需要在创建具体类的对象,而是把创建的工作交给了工厂类来创建!
* 弊端: 如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
工厂方法模式
* 提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口),每一个具体的类都有对应的工厂类(实现工厂接口)
* 具体对象的创建工作由继承抽象工厂的具体类实现
*
* 优点:
* 客户端不需要在负责对象的创建(不需显示创建具体对象)，从而明确了各个类的职责，
* 如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的 扩展性
* 弊端:
* 书写代码量大了!
设计模式之单例模式
* 单例模式核心思想:某些类的对象在创建的时候 ,在系统内存始终只有一个对象!
* 单例模式分类:
* 1)饿汉式
* 2)懒汉式(类似于多线程环境..)
*
* 饿汉式:
* 在加载那个类的时候,对象的创建工作就已经完成了!
* 懒汉式:
* 符合单例模式核心思想
* 1)自定义一个类,将无参构造私有化
* 2)在成员位置声明静态该类对象并初始化为null！
* 3)提供公共静态功能,在静态功能方法中判断是否需要创建该类对象,然后返回该类对象
*
* 如果是开发中,那么就使用饿汉式(饿汉式它不会出现问题的单例模式)
* 如果是面试中,那么使用懒汉式(因为他是可能出现问题的一种单例模式)
*
* 面试题:
* 你使用过单例模式吗?简单介绍一种单例模式,请用代码设计
* 面试官想问的是:使用设计单例的懒汉式,能否想到使用同步机制解决线程的安全问题..
*
* 懒汉式(延迟加载 -->懒加载)
* 可能会出现问题
* ---> 多线程的问题
* --->校验多线程安全问题的标准
* 1)是否是多线程环境
* 2)是否有共享数据
* 3)是否有多条语句对共享数据进行操作 (使用同步机制进行操作)
*
*
*
两种分类在设计上几乎一样:
* 1)定义个类,将该类的无参构造方法私有化
* 2)在该类的成员位置创建该类对象 并且一定要私有化,防止外界更改这个对象
* 3)在该类中提供静态成员方法(返回值就是创建的那个对象),能被当前类直接调用,static修饰
Runtime
* 每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
// public static Runtime getRuntime() 返回与当前 Java 应用程序相关的运行时对象
// public Process exec(String command)
throws IOException在单独的进程中执行指定的字符串命令。
Runtime r = Runtime.getRuntime() ;
//开启某一个进程
r.exec("notepad") ;打开记事本
r.exec("mspaint") ;打开画图Java网络编程
网络通信三要素
1)ip地址
2)端口号
3)协议(协议UDP/TCP)
IP地址: 点分十进制法:十进制.十进制.十进制.十进制
IP地址的组成： IP地址 = 网络号码+主机地址
Ip地址的分类:A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码
一般情况:国防部/大的国部门
B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码
一般情况:大学里面的多媒体教室
C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码
私人地址
端口号: 0~65535有效端口号
0-1024属于保留端口
mysql:3306
协议:
1）UDP协议 --->UDP编程
不需要建立连接通道的
数据大小有限制
不可靠连接
执行效率高
2）TCP协议 ---->TCP编程
需要建立连接通道
数据大小无限制
可靠连接
执行效率低
InetAddress：该类表示互联网协议 (IP) 地址
如果一个类中没有构造方法,没有字段,只有成员方法?有什么特征
1)应该有一些静态功能(Math类,Arrays,Collections...)
2)可能符合一种单例模式(饿汉/懒汉)
3)该类中的某些静态成员方法的返回值是该类本身
常用方法:
* public static InetAddress getByName(String host)
throws UnknownHostException在给定主机名的情况下确定主机的 IP 地址。
参数:
主机名可以是机器名（如 "java.sun.com"），也可以是其 IP 地址的文本表示形式
//创建InetAddress对象,通过来获取ip地址
//在知道主机名的情况下
InetAddress address = InetAddress.getByName("USER-20171205ZR") ;
//Ip地址对象
InetAddress address = InetAddress.getByName("192.168.10.1") ;
//上面获取到了Ip地址
public String getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
String ip = address.getHostAddress() ;
public String getHostName() 获取此 IP 地址的主机名。
String name = address.getHostName() ;简单UDP编程的接收端开发步骤：
* 1)创建Socket对象
* 2)创建一个数据报包(接收容器)
* 3)调用Socket对象中的接收的方法
* 4)解析实际传递的数据
* 5)将解析的数据(ip,数据)展示在控制台上
* 6)关闭资源
* 注意：接收端不要运行多次,会出现异常:常开就好
示例：
//1)创建Socket对象
//public DatagramSocket(int port)创建数据报包套接字对象并且将其绑定到本地主机上的指定端口
DatagramSocket ds = new DatagramSocket(10086);
// 2)创建一个数据报包(接收容器)
//public DatagramPacket(byte[] buf, int length)
byte[] bys = new byte[1024] ;
int len = bys.length ;
DatagramPacket dp = new DatagramPacket(bys, len) ;
// 3)调用Socket对象中的接收的方法
//public void receive(DatagramPacket p):接收数据报包
ds.receive(dp);//阻塞式方法
// 获取ip地址文本形式
//public InetAddress getAddress() :返回ip地址对象 数据报包类:DataGramPacket
InetAddress address = dp.getAddress() ;
String ip = address.getHostAddress() ;
// 4)解析实际传递的数据
//public byte[] getData() :获取缓冲中实际数据(从接收容器中获取)
byte[] bys2 = dp.getData() ;
//public int getLength() 返回将要发送或接收到的数据的长度。
int len2 = dp.getLength() ;//从接收容器中获取包的实际长度
String data = new String(bys2, 0, len2) ;
System.out.println("当前接收到的数据是:"+data+",来自于"+ip);
// 6)关闭资源
ds.close();
Udp编程发送端
* 1)不需要建立连接通道
* 2)数据大小有限制
* 3)不可靠连接---->传输速度快!
*
* 发送端的开发步骤:
* 1)创建发送端的Socket对象
* 2)创建数据,并打包
* 3)调用当前发送端Socket对象中的发送的方法
* 4)关闭资源
public static void main(String[] args) throws IOException {
///1)创建发送端的Socket对象
//DatagramSocket:此类表示用来发送和接收数据报包的套接字。
//创建DataGramSocket对象
//构造方法
//public DatagramSocket(int port,InetAddress laddr)
//这个构造方法,里面传递并不是Ip地址的文本形式
//构造数据报套接字并将其绑定到本地主机上任何可用的端口
DatagramSocket ds = new DatagramSocket() ;
// 2)创建数据,并打包
//DatagramPacket 数据报包
//DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)
/**
* buf - 包数据。
offset - 包数据偏移量。
length - 包数据长度。
address - 目的地址。
port - 目的端口号。
*/
//有数据
byte[] bys = "hello,udp,我来了".getBytes() ;
//获取包数据长度
int len = bys.length ;
//获取ip地址对象
InetAddress address = InetAddress.getByName("192.168.10.1") ;
//指定端口号
int port = 10086 ;
DatagramPacket dp =new DatagramPacket(bys, 0, len, address, port) ;
// 3)调用当前发送端Socket对象中的发送的方法
/*public void send(DatagramPacket p)
throws IOException从此套接字发送数据报包*/
ds.send(dp);
// 4)关闭资源*
ds.close();
}
}小结：
掌握的其实都不是很好暂时，网络编程有了大致的了解
对于设计模式和原则有了比较清晰的认识，特别是单例模式。了解设计模式确实是有助于提高代码质量
学习判断多线程编程中存在的安全问题，解决安全问题的同时避免死锁的产生，熟悉线程的等待唤醒机制，学习运用线程组和线程池，了解线程池的特点。
498
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
