LongSheng | Page 214

React Native 开发之 IDE 选型和配置

React Native 发布一年多了，有不少公司已经在线上产品中或小范围试水，或大范围应用，很多公司或开发者都在为 React Native 的生态系统作出自己的贡献。 React Native 的开发基本上是 Javascript ＋系统原生开发语言（Java，Objective-C，Swift），原生语言的开发所用的 IDE 没有多余的选择，Android 平台只能使用 Android Studio（不要告诉我你还在使用 Eclipse），iOS 平台只能使用 XCode，而开发 Javascript 的 IDE 选择就多了，从 FaceBook 官方推荐的 Atom＋Nuclide，到与 Android Studio 同系列的 Javascript IDE WebStorm，再到功能强大的 Sublime Text 3，以及微软推出的 Visual Studio Code 和 decosoftware 专门为 React Native 打造的开源 IDE Deco，甚至 Vim，NodePad++ 等等，都可以用来开发 React Native，唯一的前提能够支持识别 Javascript 语法，识别 JSX 和 React Native API 的智能提醒。接下来我们就来介绍最常用的五款 IDE 的配置和选型。 Atom＋Nuclide Atom 是由 Github 打造的下一代编程开发利器，支持 Windows、Mac OS X、Linux 三大桌面平台，免费且开源。Atom 支持各种编程语言的代码高亮，同时具备强大的代码补全功能，能够极大的提高编程效率，Atom 本质上是一个文本编辑器，而不是一个 IDE，因此在用来开发 React Native 时需要配合 Nuclide 一起使用。 Nuclide 是 Facebook 基于 Atom 的基础上开发的一个插件 IDE，可以用来开发 React Native，iOS […]

龙生 29 Nov 2017

View Details

HTML&CSS编码规范

目录 HTML 语法 HTML5 doctype 语言属性（Language attribute）字符编码 IE 兼容模式引入 CSS 和 JavaScript 文件实用为王属性顺序布尔（boolean）型属性减少标签的数量 JavaScript 生成的标签 CSS 语法声明顺序不要使用 @import 媒体查询（Media query）的位置带前缀的属性单行规则声明简写形式的属性声明 Less 和 Sass 中的嵌套 Less 和 Sass 中的操作符注释 class 命名选择器代码组织黄金定律永远遵循同一套编码规范 — 可以是这里列出的，也可以是你自己总结的。如果你发现本规范中有任何错误，敬请指正。通过 open an issue on GitHub 为本规范添加内容或贡献力量。不管有多少人共同参与同一项目，一定要确保每一行代码都像是同一个人编写的。 HTML 语法用两个空格来代替制表符（tab） — 这是唯一能保证在所有环境下获得一致展现的方法。嵌套元素应当缩进一次（即两个空格）。对于属性的定义，确保全部使用双引号，绝不要使用单引号。不要在自闭合（self-closing）元素的尾部添加斜线 — HTML5 规范中明确说明这是可选的。不要省略可选的结束标签（closing tag）（例如，</li> 或 </body>）。

<!DOCTYPE html>

<html>

<head>

<title>Page title</title>

</head>

<body>

<h1 class="hello-world">Hello, world!</h1>

</body>

</html>

HTML5 doctype 为每个 HTML 页面的第一行添加标准模式（standard mode）的声明，这样能够确保在每个浏览器中拥有一致的展现。

<!DOCTYPE html>

<html>

<head>

</head>

</html>

语言属性根据 HTML5 规范：强烈建议为 html 根元素指定 lang 属性，从而为文档设置正确的语言。这将有助于语音合成工具确定其所应该采用的发音，有助于翻译工具确定其翻译时所应遵守的规则等等。更多关于 lang 属性的知识可以从此规范中了解。这里列出了语言代码表。

</html>

IE 兼容模式 IE […]

龙生 29 Nov 2017

View Details

Thread – 多线程更新(update)数据库表的例子

目标：为提高数据库表更新（update）效率，使用多线程更新。其实这里也可以考虑另一种方法批量更新，不过如果更新失败了，同一事务（transaction）中的其他更新语句就会回滚，比较麻烦，所在还是简单点用多线程去处理。困难点：开始是想把需要更新的数据等分到线程中去处理，不过搞了一段时间都没成功，主要是没有什么办法把动态参数从线程外传进线程内。后来换了个思路，每个线程去拿一条数据去更新，拿数据时同步处理。这样之后就可以了。例子（部分外部类没有写上去，所以只能参考，要运行需要改改）：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.atomic.AtomicInteger;

import javax.annotation.Resource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

public class BaiduBaikeJob {

static final Logger logger = LoggerFactory

.getLogger(BaiduBaikeJob.class);

@Autowired

private MongoLockService mongoLockService;

@Autowired

private WeiboPersonService weiboPersonService;

@Resource(name = "globalProperties")

private PropertyPlaceholderConfigurer config;

final int THREAD_COUNT = 10;

AtomicInteger updCounter = new AtomicInteger(0);

AtomicInteger next = new AtomicInteger(0);

private CountDownLatch threadCompletedCounter = new CountDownLatch(THREAD_COUNT);

/**

* 每隔 1小时，获得百度百科里的人物信息

public void baiduBaikeRun() {

if ("true".equalsIgnoreCase((String) config.getProperty("runBaiduBaikeJob", "false")) && mongoLockService.getLock(MongoLockService.LOCK_BAIDU_BAIKE)) {

List<WeiboPerson> unBaikeFills = null;

try {

unBaikeFills = weiboPersonService.findUnBaikeFills(2000);

if (unBaikeFills != null && !unBaikeFills.isEmpty()) {

List<WeiboPerson> weiboPersonList = new ArrayList<WeiboPerson>();

for (final WeiboPerson person : unBaikeFills) {

// 获取百度百科信息

WeiboPerson weiboPerson = BaiduBaikeUtils.getBaiduBaikeInfo(person.getName());

weiboPerson.setId(person.getId());

weiboPerson.setName(person.getName());

weiboPerson.setTenantId(person.getTenantId());

weiboPerson.setGroupId(person.getGroupId());

// 更新状态

if (!StringUtils.isEmptyString(weiboPerson.getDescription())) {

weiboPerson.setFlagBaike(WeiboPerson.BAIKE_SUCCESS);

} else {

weiboPerson.setFlagBaike(WeiboPerson.BAIKE_FAIL);

}

weiboPerson.setLastUpdDate(new Date());

weiboPersonList.add(weiboPerson);

}

// 首次更新或过期更新

baiduBaikeRunInMultiThreads(weiboPersonList);

}

} catch (Exception e) {

logger.error("update baidu baike error，" + e.getClass().getName() + ": " + e.getMessage());

} finally {

try {

mongoLockService.releaseLock(MongoLockService.LOCK_BAIDU_BAIKE);

} catch (Exception e) {

logger.error("release lock error ", e);

}

/**

* 多线程处理：更新table

private void baiduBaikeRunInMultiThreads(final List<WeiboPerson> weiboPersonList) {

ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);

for (int i = 0; i < THREAD_COUNT; i++) {

executor.submit(new Runnable() {

public void run() {

WeiboPerson weiboPerson = getNext(weiboPersonList);

while (null != weiboPerson) {

try {

// 首次更新或过期更新

weiboPersonService.update(weiboPerson);

} catch (Exception e) {

logger.error("table weiboPerson update error ", e);

}

updCounter.incrementAndGet();

// System.out.println("Thread:" + Thread.currentThread().getName() + ", counter:" + updCounter + ", name:" + weiboPerson.getName());

weiboPerson = getNext(weiboPersonList);

}

threadCompletedCounter.countDown();

}

});

}

closeThreadPool(executor);

}

/**

* 同步处理：获取需要更新的一条微博人物

private synchronized WeiboPerson getNext(List<WeiboPerson> weiboPersonList){

if(next.intValue()>=weiboPersonList.size()) return null;

next.incrementAndGet();

return weiboPersonList.get(next.intValue()-1);

}

/**

* 关闭线程池

private void closeThreadPool(final ExecutorService executor) {

try {

threadCompletedCounter.await();

executor.shutdown();

} catch (InterruptedException e) {

e.printStackTrace();

}

public static void main(String[] args) {

// mock

List<WeiboPerson> weiboPersonList = new ArrayList<WeiboPerson>();

int i = 1;

while (i <= 10) {

WeiboPerson weiboPerson = new WeiboPerson();

weiboPerson.setName("a" + i);

weiboPersonList.add(weiboPerson);

i++;

}

// test multi-thread

BaiduBaikeJob baiduBaikeJob = new BaiduBaikeJob();

baiduBaikeJob.baiduBaikeRunInMultiThreads(weiboPersonList);

}

from:http://blog.csdn.net/textboy/article/details/44680289

龙生 28 Nov 2017

View Details

EF6的多线程与分库架构设计实现

1.项目背景这里简单介绍一下项目需求背景，之前公司的项目基于EF++Repository+UnitOfWork的框架设计的，其中涉及到的技术有RabbitMq消息队列，Autofac依赖注入等常用的.net插件。由于公司的发展，业务不断更新，变得复杂起来，对于数据的实时性、存储容量要求也提高了一个新的高度。数据库上下文DbContext设计的是单例模式，基本上告别了多线程高并发的数据读写能力，看了园子里很多大神的博客，均为找到适合自己当前需求的DbContext的管理方式。总结目前主要的管理方式： 1）DbContext单例模式（长连接）。即公司之前的设计。很明显，这种设计方式无法支持多线程同步数据操作。报各种错误，最常见的，比如：集合已修改，无法进行枚举操作。—弃用 2）Using模式（短连接）。这种模式适合一些对于外键，导航属性不经常使用的场合，由于导航属性是放在上下文缓存中的，一旦上下文释放掉，导航属性就为null。当然，也尝试了其他大神的做法，比如，在上下文释放之前转换为 ToList或者使用饥饿加载的方式（ps:这种方式很不灵活，你总不可能遇到一个类类型就去利用反射加载找到它具有的导航属性吧或者直接InCluding）,这些方法依旧没有办法解决目前的困境。也尝试这直接赋值给一个定义的同类型的变量，但是对于这种带导航的导航的复杂类的深拷贝，没有找到合适的路子，有知道的可以告诉我，非常感谢！以上两种方式及网上寻找的其他方式都没有解决我的问题。这里先上一下之前的Repository：

1 using System.Data.Entity;

2 using System.Data.Entity.Validation;

4 namespace MM.Data.Library.Entityframework

5 {

6 public class EntityFrameworkRepositoryContext : RepositoryContext, IEntityFrameworkRepositoryContext

7 {

8 protected DbContext container;

10 public EntityFrameworkRepositoryContext(DbContext container)

11 {

12 this.container = container;

13 }

15 public override void RegisterNew<TAggregateRoot>(TAggregateRoot obj)

16 {

17 this.container.Set<TAggregateRoot>().Add(obj);

18 this.IsCommit = false;

19 }

21 public override void RegisterModified<TAggregateRoot>(TAggregateRoot obj)

22 {

23 if (this.container.Entry<TAggregateRoot>(obj).State == EntityState.Detached)

24 {

25 this.container.Set<TAggregateRoot>().Attach(obj);

26 }

27 this.container.Entry<TAggregateRoot>(obj).State = EntityState.Modified;

28 this.IsCommit = false;

29 }

31 public override void RegisterDeleted<TAggregateRoot>(TAggregateRoot obj)

32 {

33 this.container.Set<TAggregateRoot>().Remove(obj);

34 this.IsCommit = false;

35 }

37 public override void Rollback()

38 {

39 this.IsCommit = false;

40 }

42 protected override void DoCommit()

43 {

44 if (!IsCommit)

45 {

46 //var count = container.SaveChanges();

47 //IsCommit = true;

48 try

49 {

50 var count = container.SaveChanges();

51 IsCommit = true;

52 }

53 catch (DbEntityValidationException dbEx)

54 {

55 foreach (var validationErrors in dbEx.EntityValidationErrors)

56 {

57 foreach (var validationError in validationErrors.ValidationErrors)

58 {

59 }

60 }

61 IsCommit = false;

62 }

63 }

64 }

66 public System.Data.Entity.DbContext DbContext

67 {

68 get { return container; }

69 }

71 public override void Dispose()

72 {

73 if (container != null)

74 container.Dispose();

75 }

76 }

77 }

View Code 2.设计思路及方法从上下文的单例模式来看，所要解决的问题无非就是在多线程对数据库写操作上面。只要在这上面做手脚，问题应该就能引刃而解。我的想法是将所有的要修改的数据分别放入UpdateList,InsertList,DeleteList三个集合中去，然后提交到数据库保存。至于DbContext的管理，通过一个数据库工厂获取，保证每一个数据库的连接都是唯一的，不重复的（防止发生类似这种错误：正在创建模型，此时不可使用上下文。），用的时候直接去Factory拿。等到数据库提交成功后，清空集合数据。看起来，实现起来很容易，但是因为还涉及到其他技术，比如Redis。所以实现过程费劲。也许我的能力还差很多。总之，废话不多说，直接上部分实现代码：数据库上下文建立工厂：

1 /// <summary>

2 /// 数据库建立工厂

3 /// Modify By:

4 /// Modify Date:

5 /// Modify Reason:

6 /// </summary>

7 public sealed class DbFactory

8 {

9 public static IDbContext GetCurrentDbContext(string connectstring,string threadName)

10 {

11 lock (threadName)

12 {

13 //CallContext：是线程内部唯一的独用的数据槽（一块内存空间）

14 //传递Context进去获取实例的信息，在这里进行强制转换。

15 var Context = CallContext.GetData("Context") as IDbContext;

17 if (Context == null) //线程在内存中没有此上下文

18 {

19 var Scope = UnitoonIotContainer.Container.BeginLifetimeScope();

20 //如果不存在上下文创建一个(自定义)EF上下文并且放在数据内存中去

21 Context = Scope.Resolve<IDbContext>(new NamedParameter("connectionString", connectstring));

22 CallContext.SetData("Context", Context);

23 }

24 else

25 {

27 if (!Context.ConnectionString.Equals(connectstring))

28 {

29 var Scope = UnitoonIotContainer.Container.BeginLifetimeScope();

30 //如果不存在上下文创建一个(自定义)EF上下文并且放在数据内存中去

31 Context = Scope.Resolve<IDbContext>(new NamedParameter("connectionString", connectstring));

32 CallContext.SetData("Context", Context);

33 }

34 }

35 return Context;

36 }

37 }

39 }

View Code Repository：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

1 public class RepositoryBase<T, TContext> : IRepositoryBase<T> where T : BaseEntity

3 where TContext : ContextBase, IDbContext, IDisposable, new()

4 {

5 public List<T> InsertList { get; set; }

6 public List<T> DeleteList { get; set; }

7 public List<T> UpdateList { get; set; }

9 #region field

11 protected readonly string Connectstring;

12 ///// <summary>

13 ///// </summary>

14 //protected static IDbContext Context;

15 protected IDbContext dbContext;

16 private static readonly ILifetimeScope Scope;

17 public static int xcount = 0;

18 /////// <summary>

19 /////// </summary>

20 //protected readonly DbSet<T> Dbset;

22 #endregion

24 #region ctor

26 static RepositoryBase()

27 {

28 Scope = UnitoonIotContainer.Container.BeginLifetimeScope();

29 }

31 /// <summary>

32 /// 使用默认连接字符串name=connName

33 /// </summary>

34 public RepositoryBase() : this("")

35 {

36 }

38 /// <summary>

39 /// 构造函数

40 /// </summary>

41 /// <param name="connectionString">连接字符串</param>

42 public RepositoryBase(string connectionString)

43 {

44 InsertList = new List<T>();

45 DeleteList = new List<T>();

46 UpdateList = new List<T>();

49 //*****做以下调整，初始化，建立所有数据库连接，保持长连接状态，在用的时候去判断使用连接

52 //todo 待处理

55 if (string.IsNullOrWhiteSpace(connectionString))

56 {

57 var name = DataBase.GetConnectionString(Activator.CreateInstance<T>().DbType);

58 //Context= ContextHelper.GetDbContext(Activator.CreateInstance<T>().DbType);

59 connectionString = name;

60 }

61 Connectstring = connectionString;

63 // Context = Scope.Resolve<IDbContext>(new NamedParameter("connectionString", Connectstring));

65 //Context = new TContext { ConnectionString = connectionString };

68 // Dbset = Context.Set<T>();

70 //var loggerFactory = ((DbContext)Context).GetService<ILoggerFactory>();

71 //loggerFactory.AddProvider(new DbLoggerProvider(Console.WriteLine));

72 //loggerFactory.AddConsole(minLevel: LogLevel.Warning);

73 }

75 //public RepositoryBase(TContext context)

76 //{

77 // Context = context;

78 // Dbset = context.Set<T>();

79 //}

81 #endregion

83 #region Method

85 //public virtual IDbContext GetDbContext(ILifetimeScope scope)

86 //{

88 //}

90 #region Check Model

92 /// <summary>

93 /// 校正Model

94 /// </summary>

95 protected virtual void ValidModel()

96 {

97 }

99 #endregion

100

101 #region Update

102

103 public virtual void Update(T entity)

104 {

105 Check.NotNull(entity, "entity");

106 UpdateList.Add(entity);

107 //context.Set<T>().Update(entity);

108 }

109

110 public virtual void Update(IEnumerable<T> entities)

111 {

112 Check.NotNull(entities, "entities");

113 UpdateList.AddRange(entities);

114 }

115

116 #endregion

117

118 #region PageList

119

120 public virtual IEnumerable<T> GetPageList(Expression<Func<T, bool>> where, Expression<Func<T, object>> orderBy,

121 int pageIndex, int pageSize)

122 {

123 //todo

124 }

125

126 #endregion

127

128 #region Insert

129

130 public virtual void Add(T entity)

131 {

132 Check.NotNull(entity, "entity");

133 //排除已经存在的项(对于多线程没有任何用处)

134 if (!InsertList.Exists(e => e.Equals(entity)))

135 {

136 InsertList.Add(entity);

137 }

138

139 }

140

141 public virtual void Add(IEnumerable<T> entities)

142 {

143 Check.NotNull(entities, "entities");

144 InsertList.AddRange(entities);

145 }

146

147 public void BulkInsert(IEnumerable<T> entities)

148 {

149 Check.NotNull(entities, "entities");

150 InsertList.AddRange(entities);

151 }

152

153 #endregion

154

155 #region Delete

156

157 public virtual void Delete(int id)

158 {

159 var entity = GetById(id);

160 Delete(entity);

161 // throw new NotImplementedException("Delete(int id)");

162 }

163

164 public virtual void Delete(string id)

165 {

166 throw new NotImplementedException("Delete(string id)");

167 }

168

169 public virtual void Delete(T entity)

170 {

171 Check.NotNull(entity, "entity");

172 DeleteList.Add(entity);

173 }

174

175 public virtual void Delete(IEnumerable<T> entities)

176 {

177 Check.NotNull(entities, "entities");

178 foreach (var x1 in DeleteList)

179 {

180 DeleteList.Add(x1);

181 }

182 }

183

184 public virtual void Delete(Expression<Func<T, bool>> where)

185 {

186 var list = DeleteList.Where(where.Compile());

187 Delete(list);

188 }

189

190 #endregion

191

192 #region Commit

193

194 public int Commit()

195 {

196 ValidModel();

197 //var x = Activator.CreateInstance<T>();

198 //Context = ContextHelper.GetDbContext(x.DbType);

199 //using (var scope = UnitoonIotContainer.Container.BeginLifetimeScope())

200 //{

201 // var context = scope.Resolve<IDbContext>(new NamedParameter("connectionString", Connectstring));

202

203 //var loggerFactory = Activator.CreateInstance<ILoggerFactory>();// ((DbContext)context).GetService<ILoggerFactory>();

204 //loggerFactory.AddProvider(new DbLoggerProvider(Console.WriteLine));

205 dbContext = DbFactory.GetCurrentDbContext(Connectstring, Thread.CurrentThread.Name);

206 var dbset = dbContext.Set<T>();

207 if (InsertList != null && InsertList.Any())

208 {

209 List<T> InsertNewList = InsertList.Distinct(new PropertyComparer<T>("Id")).ToList();//按照特定规则排除重复项

210 dbset.AddRange(InsertNewList);

211 }

212

213 if (DeleteList != null && DeleteList.Any())

214 DeleteList.ForEach(t =>

215 {

216 // Context.Entry(t).State = EntityState.Detached;//将之前上下文跟踪的状态丢弃

217 //dbContext.Entry(t).State = EntityState.Detached;//将之前上下文跟踪的状态丢弃

218 dbset.Attach(t);

219 dbset.Remove(t);

220 });

221 if (UpdateList != null && UpdateList.Any())

222 {

223 List<T> UpdateNewList = UpdateList.Distinct(new PropertyComparer<T>("Id")).ToList();//按照特定规则排除重复项

224 UpdateNewList.ForEach(t =>

225 {

226 //Context.Entry(t).State = EntityState.Detached;//将之前上下文跟踪的状态丢弃

227 // dbContext.Entry(t).State = EntityState.Detached;//将之前上下文跟踪的状态丢弃

228 dbContext.Entry(t).State = EntityState.Modified;

229 });//.UpdateRange(UpdateNewList);

230 }

231 var result = 0;

232 try

233 {

234 result = dbContext.SaveChanges();

235 }

236 catch (Exception ex)

237 {

238

239 // throw;

240 }

241

242 if (InsertList != null && InsertList.Any())

243 InsertList.Clear();

244 if (DeleteList != null && DeleteList.Any())

245 DeleteList.Clear();

246 if (UpdateList != null && UpdateList.Any())

247 UpdateList.Clear();

248 return result;

249 //}

250 }

251

252 public async Task<int> CommitAsync()

253 {

254 ValidModel();

255 //todo

256

257 }

258

259 #endregion

260

261 #region Query

262 public IQueryable<T> Get()

263 {

264 return GetAll().AsQueryable();

265 }

266 //public virtual T Get(Expression<Func<T, bool>> @where)

267 //{

268 // using (var scope = UnitoonIotContainer.Container.BeginLifetimeScope())

269 // {

270

271 // var context = scope.Resolve<IDbContext>(new NamedParameter("connectionString", Connectstring));

272 // var dbset = context.Set<T>();

273 // return dbset.FirstOrDefault(where);

274 // }

275 //}

276

277 public virtual async Task<T> GetAsync(Expression<Func<T, bool>> @where)

278 {

279 //todo

280 }

281

282 public virtual T GetById(int id)

283 {

284 throw new NotImplementedException("GetById(int id)");

285 }

286

287 public virtual async Task<T> GetByIdAsync(int id)

288 {

289 throw new NotImplementedException("GetById(int id)");

290 }

291

292 public virtual T GetById(string id)

293 {

294 throw new NotImplementedException("GetById(int id)");

295 }

296

297 public virtual async Task<T> GetByIdAsync(string id)

298 {

299 throw new NotImplementedException("GetById(int id)");

300 }

301

302 public virtual T Get(Expression<Func<T, bool>> @where)//, params string[] includeProperties

303 {

304 //var scope = UnitoonIotContainer.Container.BeginLifetimeScope();

305 //{

306 // var context = scope.Resolve<IDbContext>(new NamedParameter("connectionString", Connectstring));

307 //Thread.Sleep(50);

308 //lock (Context)

309 {

310 dbContext= DbFactory.GetCurrentDbContext(Connectstring, Thread.CurrentThread.Name);

311 var dbset = dbContext.Set<T>().Where(e => !e.IsDeleted).AsQueryable();

312 var entity = dbset.FirstOrDefault(where);

313 //test

314 // Context.Entry(entity).State = EntityState.Detached;//将之前上下文跟踪的状态丢弃

315 return entity;

316 }

317

318

319 //}

320 }

321

322 public virtual IEnumerable<T> GetAll()

323 {

324 //Thread.Sleep(50);

325 //lock (Context)

326 {

327 dbContext = DbFactory.GetCurrentDbContext(Connectstring, Thread.CurrentThread.Name);

328 var dbset = dbContext.Set<T>().Where(e => !e.IsDeleted);

329 //test

330 //dbset.ToList().ForEach(t =>

331 //{

332 // Context.Entry(t).State = EntityState.Detached;//将之前上下文跟踪的状态丢弃

333 //});

334

335 return dbset;

336 }

337

338

339

340

341 //var scope = UnitoonIotContainer.Container.BeginLifetimeScope();

342

343 // var context = scope.Resolve<IDbContext>(new NamedParameter("connectionString", Connectstring));

344

345 }

346

347 public async virtual Task<IEnumerable<T>> GetAllAsync()

348 {

349 //todo

350 }

351

352 public virtual IEnumerable<T> GetMany(Expression<Func<T, bool>> where)

353 {

354 //using (var scope = UnitoonIotContainer.Container.BeginLifetimeScope())

355 //{

356 // var context = scope.Resolve<IDbContext>(new NamedParameter("connectionString", Connectstring));

357

358 // var dbset = context.Set<T>();

359 //Thread.Sleep(50);

360 //lock (Context)

361 {

362 dbContext = DbFactory.GetCurrentDbContext(Connectstring, Thread.CurrentThread.Name);

363 var dbset = dbContext.Set<T>().Where(e => !e.IsDeleted);

364 //test

365 //dbset.ToList().ForEach(t =>

366 //{

367 // Context.Entry(t).State = EntityState.Detached;//将之前上下文跟踪的状态丢弃

368 //});

369 return dbset.Where(@where).ToList();

370 }

371

372 //}

373 }

374

375 public virtual async Task<IEnumerable<T>> GetManyAsync(Expression<Func<T, bool>> where)

376 {

377 //todo

378 }

379

380 public virtual IEnumerable<T> IncludeSubSets(params Expression<Func<T, object>>[] includeProperties)

381 {

382 //todo

383 }

384

385 #region navigation

386 /// <summary>

387 /// 加载导航

388 /// </summary>

389 /// <param name="where"></param>

390 /// <param name="includeProperties"></param>

391 /// <returns></returns>

392 //public virtual T Get(Expression<Func<T, bool>> @where, params Expression<Func<T, object>>[] includeProperties)

393 //{

394 // using (var scope = UnitoonIotContainer.Container.BeginLifetimeScope())

395 // {

396

397 // var context = scope.Resolve<IDbContext>(new NamedParameter("connectionString", Connectstring));

398 // var dbset = context.Set<T>();

399 // var query = includeProperties.Aggregate<Expression<Func<T, object>>, IQueryable<T>>(dbset,

400 // (current, includeProperty) => current.Include(includeProperty));

401 // return query.FirstOrDefault(where);

402 // }

403 //}

404

405 //public virtual T Get(Expression<Func<T, bool>> @where)//, params string[] includeProperties

406 //{

407 // //反射获取导航

408 // var includeProperties =

409 // Activator.CreateInstance<T>().GetType().GetProperties().Where(p => p.GetMethod.IsVirtual).Select(e => e.Name).ToArray();

410

411 //todo

412 //}

413 #endregion

414 public List<TDynamicEntity> GetDynamic<TTable, TDynamicEntity>(Expression<Func<TTable, object>> selector,

415 Func<object, TDynamicEntity> maker) where TTable : class

416 {

417 //todo

418 }

419

420 public List<TDynamicEntity> GetDynamic<TTable, TDynamicEntity>(Func<TTable, object> selector,

421 Func<object, TDynamicEntity> maker) where TTable : class

422 {

423 //todo

424

425 }

426

427 #endregion

428

429 #region Count

430

431 public virtual async Task<int> CountAsync()

432 {

433 //todo

434 }

435

436 public virtual async Task<int> CountByAsync(Expression<Func<T, bool>> where)

437 {

438 //todo

439 }

440

441 #endregion

442

443 #region Exists

444

445 public virtual bool Exists(string id)

446 {

447 throw new NotImplementedException();

448 }

449

450 public virtual bool Exists(int id)

451 {

452 throw new NotImplementedException();

453 }

454

455 public virtual async Task<bool> ExistsAsync(string id)

456 {

457 throw new NotImplementedException();

458 }

459

460 public virtual async Task<bool> ExistsAsync(int id)

461 {

462 throw new NotImplementedException();

463 }

464

465 public virtual bool Exists(Expression<Func<T, bool>> @where)

466 {

467 throw new NotImplementedException();

468 }

469

470 public virtual async Task<bool> ExistsAsync(Expression<Func<T, bool>> @where)

471 {

472 throw new NotImplementedException();

473 }

474

475 #endregion

476

477

478 #endregion

479 }

http://blog.csdn.net/wodeai1235/article/details/54923072

龙生 28 Nov 2017

View Details

多线程40个问题汇总

这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍，不会去看网上的答案，因此可能有些问题讲的不对，能指正的希望大家不吝指教。 40个问题汇总 1、多线程有什么用？一个可能在很多人看来很扯淡的一个问题：我会用多线程就好了，还管它有什么用？在我看来，这个回答更扯淡。所谓”知其然知其所以然”，”会用”只是”知其然”，”为什么用”才是”知其所以然”，只有达到”知其然知其所以然”的程度才可以说是把一个知识点运用自如。OK，下面说说我对这个问题的看法：（1）发挥多核CPU的优势随着工业的进步，现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的，4核、8核甚至16核的也都不少见，如果是单线程的程序，那么在双核CPU上就浪费了50%，在4核CPU上就浪费了75%。单核CPU上所谓的”多线程”那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换得比较快，看着像多个线程”同时”运行罢了。多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程，可以真正发挥出多核CPU的优势来，达到充分利用CPU的目的。（2）防止阻塞从程序运行效率的角度来看，单核CPU不但不会发挥出多线程的优势，反而会因为在单核CPU上运行多线程导致线程上下文的切换，而降低程序整体的效率。但是单核CPU我们还是要应用多线程，就是为了防止阻塞。试想，如果单核CPU使用单线程，那么只要这个线程阻塞了，比方说远程读取某个数据吧，对端迟迟未返回又没有设置超时时间，那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题，多条线程同时运行，哪怕一条线程的代码执行读取数据阻塞，也不会影响其它任务的执行。（3）便于建模这是另外一个没有这么明显的优点了。假设有一个大的任务A，单线程编程，那么就要考虑很多，建立整个程序模型比较麻烦。但是如果把这个大的任务A分解成几个小任务，任务B、任务C、任务D，分别建立程序模型，并通过多线程分别运行这几个任务，那就简单很多了。 2、创建线程的方式比较常见的一个问题了，一般就是两种：（1）继承Thread类（2）实现Runnable接口至于哪个好，不用说肯定是后者好，因为实现接口的方式比继承类的方式更灵活，也能减少程序之间的耦合度，面向接口编程也是设计模式6大原则的核心。 3、start()方法和run()方法的区别只有调用了start()方法，才会表现出多线程的特性，不同线程的run()方法里面的代码交替执行。如果只是调用run()方法，那么代码还是同步执行的，必须等待一个线程的run()方法里面的代码全部执行完毕之后，另外一个线程才可以执行其run()方法里面的代码。 4、Runnable接口和Callable接口的区别有点深的问题了，也看出一个Java程序员学习知识的广度。 Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。这其实是很有用的一个特性，因为多线程相比单线程更难、更复杂的一个重要原因就是因为多线程充满着未知性，某条线程是否执行了？某条线程执行了多久？某条线程执行的时候我们期望的数据是否已经赋值完毕？无法得知，我们能做的只是等待这条多线程的任务执行完毕而已。而Callable+Future/FutureTask却可以获取多线程运行的结果，可以在等待时间太长没获取到需要的数据的情况下取消该线程的任务，真的是非常有用。 5、CyclicBarrier和CountDownLatch的区别两个看上去有点像的类，都在java.util.concurrent下，都可以用来表示代码运行到某个点上，二者的区别在于：（1）CyclicBarrier的某个线程运行到某个点上之后，该线程即停止运行，直到所有的线程都到达了这个点，所有线程才重新运行；CountDownLatch则不是，某线程运行到某个点上之后，只是给某个数值-1而已，该线程继续运行（2）CyclicBarrier只能唤起一个任务，CountDownLatch可以唤起多个任务（3）CyclicBarrier可重用，CountDownLatch不可重用，计数值为0该CountDownLatch就不可再用了 6、Volatile关键字的作用一个非常重要的问题，是每个学习、应用多线程的Java程序员都必须掌握的。理解volatile关键字的作用的前提是要理解Java内存模型，这里就不讲Java内存模型了，可以参见第31点，volatile关键字的作用主要有两个：（1）多线程主要围绕可见性和原子性两个特性而展开，使用volatile关键字修饰的变量，保证了其在多线程之间的可见性，即每次读取到volatile变量，一定是最新的数据（2）代码底层执行不像我们看到的高级语言—-Java程序这么简单，它的执行是Java代码–>字节码–>根据字节码执行对应的C/C++代码–>C/C++代码被编译成汇编语言–>和硬件电路交互，现实中，为了获取更好的性能JVM可能会对指令进行重排序，多线程下可能会出现一些意想不到的问题。使用volatile则会对禁止语义重排序，当然这也一定程度上降低了代码执行效率从实践角度而言，volatile的一个重要作用就是和CAS结合，保证了原子性，详细的可以参见java.util.concurrent.atomic包下的类，比如AtomicInteger。 7、什么是线程安全又是一个理论的问题，各式各样的答案有很多，我给出一个个人认为解释地最好的：如果你的代码在多线程下执行和在单线程下执行永远都能获得一样的结果，那么你的代码就是线程安全的。这个问题有值得一提的地方，就是线程安全也是有几个级别的：（1）不可变像String、Integer、Long这些，都是final类型的类，任何一个线程都改变不了它们的值，要改变除非新创建一个，因此这些不可变对象不需要任何同步手段就可以直接在多线程环境下使用（2）绝对线程安全不管运行时环境如何，调用者都不需要额外的同步措施。要做到这一点通常需要付出许多额外的代价，Java中标注自己是线程安全的类，实际上绝大多数都不是线程安全的，不过绝对线程安全的类，Java中也有，比方说CopyOnWriteArrayList、CopyOnWriteArraySet （3）相对线程安全相对线程安全也就是我们通常意义上所说的线程安全，像Vector这种，add、remove方法都是原子操作，不会被打断，但也仅限于此，如果有个线程在遍历某个Vector、有个线程同时在add这个Vector，99%的情况下都会出现ConcurrentModificationException，也就是fail-fast机制。（4）线程非安全这个就没什么好说的了，ArrayList、LinkedList、HashMap等都是线程非安全的类 8、Java中如何获取到线程dump文件死循环、死锁、阻塞、页面打开慢等问题，打线程dump是最好的解决问题的途径。所谓线程dump也就是线程堆栈，获取到线程堆栈有两步：（1）获取到线程的pid，可以通过使用jps命令，在Linux环境下还可以使用ps -ef | grep java （2）打印线程堆栈，可以通过使用jstack […]

龙生 28 Nov 2017

View Details

格式化MYSQL时间戳函数FROM_UNIXTIME

对MYSQL没有进行过深入的研究，基础知识匮乏，一遇到问题只能手册，看来要把MYSQL的学习安排进时间表了。函数：FROM_UNIXTIME 作用：将MYSQL中以INT(11)存储的时间以"YYYY-MM-DD"格式来显示。语法：FROM_UNIXTIME(unix_timestamp,format) 返回表示 Unix 时间标记的一个字符串，根据format字符串格式化。format可以包含与DATE_FORMAT()函数列出的条目同样的修饰符。根据format字符串格式化date值。下列修饰符可以被用在format字符串中： %M 月名字(January……December) %W 星期名字(Sunday……Saturday) %D 有英语前缀的月份的日期(1st, 2nd, 3rd, 等等。） %Y 年, 数字, 4 位 %y 年, 数字, 2 位 %a 缩写的星期名字(Sun……Sat) %d 月份中的天数, 数字(00……31) %e 月份中的天数, 数字(0……31) %m 月, 数字(01……12) %c 月, 数字(1……12) %b 缩写的月份名字(Jan……Dec) %j 一年中的天数(001……366) %H 小时(00……23) %k 小时(0……23) %h 小时(01……12) %I 小时(01……12) %l 小时(1……12) %i 分钟, 数字(00……59) %r 时间,12 小时(hh:mm:ss [AP]M) %T 时间,24 小时(hh:mm:ss) %S 秒(00……59) %s 秒(00……59) %p AM或PM %w 一个星期中的天数(0=Sunday ……6=Saturday ） %U 星期(0……52), 这里星期天是星期的第一天 %u 星期(0……52), 这里星期一是星期的第一天 %% 一个文字“%”。例子：

1	SELECT FROM_UNIXTIME(1234567890, '%Y-%m-%d %H:%i:%S')

[…]

龙生 28 Nov 2017

View Details

Random 类

表示伪随机数生成器，这是一种能够产生满足某些随机性统计要求的数字序列的设备。若要浏览此类型的.NET Framework 源代码，请参阅 Reference Source。命名空间: System 程序集: mscorlib（位于 mscorlib.dll）继承层次结构 System.Object System.Random 语法 C#

[SerializableAttribute]

[ComVisibleAttribute(true)]

public class Random

构造函数名称说明 Random() 新实例初始化 Random 类，使用依赖于时间的默认种子值。 Random(Int32) 新实例初始化 Random 类，使用指定的种子值。方法名称说明 Equals(Object) 确定指定的对象是否等于当前对象。（继承自 Object。） Finalize() 在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。（继承自 Object。） GetHashCode() 作为默认哈希函数。（继承自 Object。） GetType() 获取当前实例的 Type。（继承自 Object。） MemberwiseClone() 创建当前 Object 的浅表副本。（继承自 Object。） Next() 返回一个非负随机整数。 Next(Int32) 返回一个小于所指定最大值的非负随机整数。 Next(Int32, Int32) 返回在指定范围内的任意整数。 NextBytes(Byte[]) 用随机数填充指定字节数组的元素。 NextDouble() 返回一个大于或等于 0.0 且小于 1.0 的随机浮点数。 Sample() 返回一个介于 0.0 和 1.0 之间的随机浮点数。 ToString() 返回表示当前对象的字符串。（继承自 Object。）说明若要查看此类型的.NET Framework 源代码，请参阅 Reference Source。您可以浏览源代码、下载脱机查看参考资料和调试; 在逐句通过源（包括修补程序和更新）see instructions. 伪随机数字从一组有限的数字选择以相同的概率。因为数学算法可用于选择它们，但它们是充分随机实用的角度而言，所选的数字不完全随机的。当前实现 Random 类根据 Donald E.Knuth 删减随机数生成器算法的修改版本。有关详细信息，请参阅 D.e。 Knuth。计算机编程，卷 2 的艺术︰ Seminumerical 算法。 Addison-wesley，Reading，MA，第三个版本，1997年。若要生成加密性极安全的随机数字，如一个适合于创建随机密码，使用 RNGCryptoServiceProvider 类或从派生类 System.Security.Cryptography.RandomNumberGenerator。在本主题中：实例化的随机数字生成器避免多个实例化 System.Random 类和线程安全生成不同类型的随机数字替换您自己的算法如何使用到 System.Random… 检索相同的随机值序列检索唯一的随机值序列 […]

龙生 28 Nov 2017

View Details

ISO 2 Letter Language Codes

The codes below, which are sorted alphabetically by language (not language code) are to be used with the core lang attribute to identify the language contained inside the element that the lang attribute is applied to. Table 1. Language Codes Language Code Abkhazian AB Afar AA Afrikaans AF Albanian SQ Amharic AM Arabic AR Armenian HY Assamese AS Aymara AY Azerbaijani AZ Bashkir BA Basque EU Bengali, Bangla BN Bhutani DZ Bihari BH Bislama BI Breton BR Bulgarian BG Burmese MY Byelorussian BE Cambodian KM Catalan CA Chinese ZH Corsican CO Croatian […]

龙生 28 Nov 2017

View Details

JS离开页面执行函数 onbeforeunload与onunload事件

阅读目录 onbeforeunload定义和用法 onunload定义和用法在最近的项目中，需要做到一个时间，就是用户离开页面的时候，我需要缓存页面其中一部分的内容，但是我不需要用户刷新的时候也缓存，我只希望在我用户离开的时候执行这个函数。百度之，有onbeforeunload与onunload这两个事件，但是onbeforeunload在用户刷新的时候也会执行。搞得我弄的挺久的，所以想在这里做一个小小的总结 onbeforeunload与onunload事件 onbeforeunload定义和用法 onbeforeunload 事件在即将离开当前页面（刷新或关闭）时触发。该事件可用于弹出对话框，提示用户是继续浏览页面还是离开当前页面。对话框默认的提示信息根据不同的浏览器有所不同，标准的信息类似 "确定要离开此页吗？"。该信息不能删除。但你可以自定义一些消息提示与标准信息一起显示在对话框。注意：如果你没有在 <body> 元素上指定 onbeforeunload 事件，则需要在 window 对象上添加事件，并使用 returnValue 属性创建自定义信息(查看以下语法实例)。注意：在 Firefox 浏览器中，只显示默认提醒信息（不显示自定义信息）。使用方法： 1、 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>test</title> </head> <body onbeforeunload="return test()"> </body> <script type="text/javascript"> function test(){ return "你确定要离开吗"; } </script> </html> 或者： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> […]

龙生 28 Nov 2017

View Details

« Previous 1 … 213 214 215 … 432 Next »

April 2024
M	T	W	T	F	S	S
« Mar
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30