• 热门专题

JAVA多线程新手指引

作者:凌.风  发布日期:2014-12-11 19:46:53
Tag标签:线程  新手  
  • 一、简述进程与线程的关系       说到多线程就不得不说进程,那么什么是进程:简单的来说就是正在进行中的程序。 在windows中,我们可以直观的看到的正在运行中的程序,即进程,如图: MFCy6hMaXg06tXTvGiC7tXRPGgQSvOANAgIdHSPjob9XdDc2tQ0sCcqUKpLS3Vq0qAQmu0UhxpDRXGgliTbVWSCNMl2ZfKjQ4Ve7gThrY7h0TM8BpbPyPabOAEzECgvhAehmPHS2+9WzJ5PoKNGghTSN+TIRBC2CdB9exBRFBFH7aKoXRxzSGJ2acwhi2Et+qhTDlZTjziw1i4iDSOSEGo3gsVwrAsgTMcCEKTCx/FbeH4LD5Ug2jrm+bHWMVGFqA1xFRqYXtBkTsaGNDf6PwHVjUWFbg3FrSG7NWQ3kKB6AOBUDThV/U5Vv0PZ51D2OZS99uEe+3CPXdHtUHTbh7vtCgx5NyLvQuRdiLwTkXci8g4UWTsia0ek7YiUZJO0wuIWWNRsFTZZBI0WQYOZV2fi1Jg41QZ2pYFVoWeW6RmlOnRfDXQjDQIFRDRpZPfp5buing/yJdWCEAtrqAVaWqGWVqilFenoRXpGsQFffJ5VamSVGVll+J4c2eFkx8ypuGcqk3AzqcoCr4o4lGThVVtTqMkO2PBDUGsV1AFgQR22Rn3KYvWwqAEWgfXqG9FV68VXbGDzD3ETImlGJNiS9dIWdMl6WZtd1uaQkRxyErpevaLDqehwKjqdw51OsOeHstul7HapetBl6tV9bnXaMvUDyTXqsX0+vDqyV0chLFOfXKzep6f6DFRir6hXT/MZiO16Go5HT/OCvyA9zQPEqqOhPtXR3DoqiDZcWiqmUZBOEWgyoSYINAnZoSI71BQ7CtmuIidVq6E4NLg96R4dw2Ng+gwsv4kdMHMCFm4QbAmMSpNA0o2CMCy4fXP2iUcweyb3iczcuWxBgWIOFUQQQQQRRhER0GjULgE/I/gWmDZJ2CYKwcIQ2uwVgC4/v5nvN/N8OFiUlw0OCiq7FPGhpDWNDSyvHm8gMz06rDtGx8CbEliQCIRIcWsxG2rIbs2QWzPkVg+hZlQNuFT9TuWAS9nvUvY7h/ucw71ORa9T0QPCQwcqxC67vMsu70RkHYisAxjQJiXZpCSbpM0maYMlrTZxK1ijDBYDWmBRi1XUnETYBAubYGGTVXgFNOss/AYLv87CqzVza8ycahO7ysiqQHcoAlsS0YvBrm06apGOWohRgJPmUC0lK5e/LlnESr6kXhANGRQD5fFNkAqxTZDADkilRibY46jMxCozs8vM6RtvZN/giECF5WuQbROkdKpSAfFmCnAKNdnh38Ap+3zU2QBg0yQUsNtHg03UiCTBdk8SN9nF+O5JYN+klK2TnDJ836QOp6LDpehwKdBNk9zopkk9blWPR9XrUSW3S/IStkvKsleSjuzXUXy65HZJwJ5+VKM0n57mN+DjS3T8Jx6lgra/V4dHqZhMU4ISvMVGI8iU6tLgpAgUx4EnVGQU3KdqNO1UU5zoTWguLQ10LPgMTJ+RFTCxA2Yuvs1lOOsu5TZBJNOeUZswG1n31+QTwTdJj9oE6FXAoYgohoiiiDAKtpaEhai2rYKQhRc08wJgVMTI8ROs59VnwsTxYU1jr57h3TF8ehSvnuHV0QnQvDqaV0vzamkeLZWIW0txayhuLcWjJRMUCcLGIZcK+HHAqQKt5j6nss+p7HUqe0G3kUPR7VB0OeSoHO2yTrus0y7ttEs77NJ2u7TdLiXZJSRE0oaI2xBxKyJusYla0F5/1IagP6sRFuK7ODTAaM9XvVWA9YihgCXRaq3cWgu3Bv1bZVea2RUmVoWJVY7uCAR2vqQXG+jFBlqxgVaEUYijT4OalYL7QLcAd9MuXhLbibPIQC8y0IuNjBITs9TMAoCNkQm7b4JtNe8RboWVW0kEXoiqJLwFyKZIfgq2FGqzAjbszISwcye6eadd1GjHNu90iJscEkCzQ9LslKK7eDqlLU5Zq1PW6pK1ueQkjHa3ogNluNM93OkZ7vIouzzKbg+6c2evV93rVfd5sW07fZoBn3bArx30awf9uiG/bsivIwd0ZD9ATwmkQA3oqQEDNWCgBvS0gAHFb6D7DXS/HksY6H493Z+0Kp2YQMWqI4L+FacPAAClaqg4SaWqKTjO+XFpKPglbi3No6N7dQyfgek3sAImdtDMCVm4YQsvDOP2BNsJE7AJojbMnksfeej2zdmYXRhDksyO+a9PRK5PhO+XyPWJyOxEmMj1q6HZq6HZq6GZ8eDMeHBmPHBtPHBtLHBtzH9tzH9tNAvTqVwb9QGm52PENz3izcBDZGrEM5XA0ok03FNx91TcPRl3pRBzTcacBBwoUcdk1D6BE7FPRJGJCMCGErZdDcPZsKYTsl4NWa6GLOOpXA2ZUYLmq0HTeNA0HjSNAQKmsYAxG4Z58X+f6EcXJL18wADqPx7EMV0NAdCHMHF/hC3fMVaUyNcFzmQyCrDNx1TUNhVFpqLIVIyIPUncPhV3TBNJOAm4CLinR9zXiIx6MLyp+K6N+mbGFsaP/US59nWYHvVPj6X/1aeS5a9+agRleiSZvivTgFH/9FhgeixwbSx4bSw4Mx6aGUc1lRTXRHh4zBdDBERu35xdCux55+Zs3C7EmR3397TVvvvqxkUWWWSRRXraamfH/HFEiHMHteeSh+7cuj7iEOHMTUTee3XjX/7yfxZZZJFFFnnv1Y1zE5GEXYhz5+bs0iUPQcsy7TkZee+1jX/+y1/+9Oe/MFmsjz76eNeu3T84H330MZPF+tOf/7LIIoss8r3x57/85b3XNs5NREbswhEHyp1bs8sWsOed//kzmUJ/550DlVU1baSOH5zKqpq9r75GptBvfvWnRRZZZJHvhzv/8+ekPe33Zs+v7vzp3fc/rKyu7e0f4vCEPzh8oaS8ovrd9z+8/uWdRRZZZJHvh6/u/Om91zbOTYQTwJ524Yg9xZ6zeEQ64hACe9766k/bX9nZ3tnLFUi1ems2GB8vh36qzHrKqq3cvvwQg/gRerlmnvvcEwazXau3bn9l57Xrt7NjKV4D/edFC5beR7923XFxzR8G5is/9Icsy8Pto897/++IoT+suezIyKe/kX35OnDM/0t9m9Df+JpfNLAPe/6LLPK3wq2vcHsKRjDu3MTteXN2hKBVMGo09+Wdl7fld/UMiWVavck5D40vQ6sO0bKcqtyG5qOJqnxoW2NaGconq6BtjXoT79AKghlWfHpoG7T8E15aYaPFbTC7Xt6WPzZ5c35or0G/Pq+/2fN6pnHS81/rA5cg5596qyfjVtrPfw29TkM/6gtXp94H5Pe8Dq3+HFmwPtnoe2shMUJZ7tnzevJLs9az53UoWVs8/6nC899SDV/ro72Gf3iqUIs+t/SHmbWe2JNEzj+FP3P8qb7Vc9+PcZFFvhfmvrzz3qsbr0+EE4ggkWbPpQR7guEkYM/rN+68tC2/p58mHTaaYB/gk5UL/+FD0MqTNNhnYp5cARJw8zaQqN0JvdKM38eUUkb4yUpoWy3hFCz8ZGXuJ0xfSnnYZ4J9L23LT1z98i70vgW9Rk1c/TJx1Xbuqbc6085qC1c/VagEifTaY4XxMuBu0K/PaQmXQ9De3i+x+xNOfX06X/v1uQtvrb5QuBetMI7t3FPZHu989ex9K5mJXb639xvWkLo3eU80rbzw69UXbGnPVnnh3+CBdL6W8V3JJ4lXifgkwR2+6WNcZJHvjus3gD1DcRs/jvDjiCBhF6Bj7pg9BQmMuYnwe69uGJ+8uXHz9tZOCkeoV2g9RHo/XrWlPCVHUb5z2ccCYgHopSaQn/mnD0oWvwRhNxF8uBzKvCF6h3Q2bt5u901l5VgusLeRkGk8lvtGfVpJ4Rcrc7/gEBMZhet3QjuaQWb/DghPYzS/AUHYbZvfgHb2z1elBajfCUHgzs1vrDxptDe/AUFQtlsZj+VmVIBwk+z1FH6x8hvVsH9Hyn+xN+p9/TugN+qFX6yEnjomTFYMP3Y0p12CFiPUMOMX+aaVXGSR74PxyZvvvbrh+kQobuPFEX4c4RPs+chDd27OJlLt+S5mz/YeBl9qURkDKVBPL9vWQswp3Zb7Ryr+sWUrBEHbWlRGyR9XYPmVu6CUSwinjJI/roC2VmZ8xYrT/Wnfawxs3Lzdq4cUMgAAIABJREFU7puel+Y3Vp401WcxNgRBELRzwO6btgsvrsy9yCEkOCefWnnSZPeZjuW+Ue+btvtMx3KfOiZEbwiBwikM7ICwAvjd7pl5q0eo593L5F7kEOsJbgt+Qd805+RTePo+aoiBPxDwK+MPB9rRnHKWc/KpHc2gDmh9sASxhviF08mKQdj977+Siyzy3TI+efPdVzfMXg1FYW7Mxovb+HEb/w7xXaNMe16durVpy/aufpZ42KazRlKRf7zyyY8Z2EfG2eUrz5Kxs+QjTy7fvmf5dpKOcXb5dhJapmYPhKetEZ2V9DK0pyJ5t6QWlh+RZxRIsmnLdmfg2ry0vLHqtAmkeafX5LdccwYG8nMv8ohlJBdXgRwswTu9ZtVpkzNg+jT3jcbANWdgIB8CiWvOljegtMsD15wB06e5UH4LSBMKfw0yaoXeNu1Wpk9PD6Rdi/1eGV8tubgK/Uis3v3UkHd6TZqrV52+mA+9kb8L/Zjfgn4LfmA5az6VEBPEr04pjx342ft7jIss8p1zdeoWak8rFxfoPPZEMHtO39q05ZXOPqZQbtWYgunQTi9fcXrAFNSYWl+Ccj+iJU+VfXJ6gHZ6+bbWlPJVuyFiTvLyoMYk/WgF9FJV2ldIP1qRclutOaQ1hzZtecUVnJmX1n2rTptB+spuKL91xhUczM+9xCeWkV5aBXKwBP/0mvzWGVfQ/GnuvivEAsEZV+s+KO3yICi55lNpZvreGczPHlLuu0Ioxs+wGKqq1tRfJFkrKL91xiW9tCrlPvddQ+yq1n2rTl/KT61b8nFlPsCsTxKvHvE/RPKe91fJRRb5zrk6fevdVzfMjgcjVk7UOp89ERRgz4npW5u3vtLVxxQrrHpLKAs1u0Eb8hAj4xTjzPLtbViBjGPFGYql7WVodyVaXnZoBfRyTdpNiAWSbN76iic0My9t+1adMYMElHtJEJrxhAZ3gkTbPmj3oCc045FdWgXiqd37VuVeEoRmmnavOSGb8YTMJ3L3NYFLIJAAaWhnW/q3QCkF8PS9g9UqBbwCM6CeO3PXoHUmIDizBqtP+lcLzqyBdg+Cnynf9XVriD2irAf27cnaYlXCf6msT9J8Ijf1Scourfqmj3GRRb5zJqZvvfvqhpnxYNjCjlg5IPxMtSeSbs/Ja19t3vpK7yBHpkKMtmgW6vaAP6dtdRmnWJ+teKU9vXBKTvs26MlPWCCt+GRlxk1Yn62A9lQScgzWsMEa3rz1FW94dj6EZ9asOmMRnlkDPXlJiGZaTj6J/9nPNu9GE8mr2vZBEARBa07K8MyhnYSPwjNrUs7KLq0i3kF2aRW0r3n+Ks3D0Dwdm9itZJdWPXlJiNYt019Z6olVZs2qJzMz76+G2FVt+1adsYD85t34t1tOPrnv5Bk8Ol5z8gxezHLySXAtsYaWk0+mPnlixe6zkoss8p0zee2rd1/dMDMWCJvZuEBvL2zPqZnbW17c0U/mKTROq3OESA1oduZ3ET+u/FSVLMM7txI7i9L4KpSaU5MPbW8EadWRVXh63vJGOGKEI1te3OGPzmWn/U0IWpP7JLSrfZ4CGYg/WwNBb7ZE5/xRyi4IgvZQQH7LntSbKAoIXXZrTilSvxS76lukZc+bLfPcXPzZGrxu6fWMwqeehKAnC8Rpj+V+akjZhT6ZOX/7m7mfwS17Un598DH3MzjjSaZcS6ghfOrJzKea/Irv4jEussg3Z2rm9ruvbrg2FgiamGEzO2LlRKycrPbkJxA+sOf07O0tL+4YogrUerfdPQY4tgqCIGjHlTE8B4dzYjUEQdCq8xz3mJ1/fmV+T0qBK69BaTn88ytB4Sxoj61afYyfkmlGomYkuuXFHcHYXFZa9645PTwXjMGnn4SyH3spyfLDBbkQlPsZTLyD9LM1aJnhgtwnC6TzfBEB+PST4Eu/Bq1752sTZ9Sz482s53d3EH6Lu9TzfmqYTsebaQ9q3m/BKpwsf09P8tuo5CKLfDdMz6L2DBgZIRMLhJ+Z9uSn2XPrSzvINKHG4HF4xr8LuCdWQzt7M+3QsBNaeUKbVtjqiFsd8a0v7QjFb3wPyM79GtpLWdhybXuh3HPw91Of+6vnX38N/0oqucgi84HZ0x8wMIImJhDo7ZszhNWRET7O9Ynwu3s3XLt+580/vN/RQ9OavE7f1R8ch3fc4R1/8w/vhxNfLrLIIot8P1y7fufdvRumR/1+Pc1vYIAI9PaXWe1p412fCL27d8PM9Tut7eS3DxzkCNTAXD8sKp3rjx9/2tpOjozcXGSRRRb5fphB7enz6ah+Az1gYASMDNyeD96+ORuDeTjXr4YO7N3AERk5IuPZC2VbX9r57HPrfnC2vrTz7IUyUKtFFllkke+NA3s3TI/4PFqqV0f16Wh+A+OrL2eWPvIg9MQjD96+ORuBuWAsKWLlzF4N7d+zfmbxWDwWj8Vj8ZiZ2b9n/VTCC/bf9WgpXh3tqxvXnnjkQeiJhx+8fXMGVyew5zu71/3QFV48Fo/FY/H4qzje2b1uMuF1qgadqiG3muzWUG7duPbEww9Cjz/8b7e/nAmZOTgz46G3d+X90BVePBaPxWPx+Ks43t6VN5Hw2pWDDtWgUz3kVJNv3bj2+MP/htnTwgla2ICZ8eCiPRePxWPxWDzA8fauvIm4x64csCsHHMpBh4ro1o3ppD1xdf7N2PN//vM///r5oR/S4rF4LB53P4j2BAK9NTf9+MP/hvZ7hq0cnL+Nfs8f3IyL9lw8Fo+/jeOd3esmEx6HcsChHHSqBp2qwVtz0088jI4azUZhLs7fxpj7D27GRXsuHovH38axf8/6yYTXqRpyqcguNdmtxkaNlj7y4J3/v733DG7jShN28e/W/XGr7rezHluWZFtWGFvyVE3V3L1hvvnut7uzs2PZ3t3xzDqMJcue8Vi2pR1bliXLsmzZEhWZKTEoWE4SrcicM6nIAAaQBBMYwYCcAyFKvrg/Gmw1+5w+3Y3YDbxPvYU6ODjn9EH32w+6yW7A65jprabDaZp4Z9PGWE84VGJuRrAnAMQH72zaaJnVDN0uGL5TSIXPbVu/ZvmD3zWig/pdI+wox1Nz5BIxN6OQiPlagoiziLJWEoT3Nm+0zmlGWgtHWos0bUWatiKf27Z+8ffcnbqBep26jgq3eeq915/DjnI8Nee+TIi5GYVErFeSIKjdMtazeADMhwuwZ4R47/XnrLpRTXsxHT63jfo995UL8079YEMgBurd5qltW57HjkJliVMOxNyMQiLWK4mf+ww7xHouTifMh48mUdZKgrBty/M2/eiYsoQOn8e2Ye1KxYZ1K+/NOw2DDYbBBsNgvWGw3mOZ2h6n9vQzUCgUXAWqTIF9yS8esGdYgPmQZxJlrSQI27c8b9ePjXeWjikD4fPYN6xbqXhm3cp7807jUCMdHot2+5YXsKMcT825d++egxuFQkF4VQjUCKyvgAxicbz2ZFmSpUuyWMNlz6DXT9S4d+8eZQfsdmdNBjs3ZiVdDvpdkOfDu1AykZuPEELcstRMoqyVBGH7lhfs+rHxzrJxZdm4snRcWebz2J9B7WkQYE/ykhQKBbaSC1YDdBBWmXcoCoH25FIk+hKXYUOxJ/Z9oW+T/PbJmyNEmHZAX2UtHZ0Ma4MyH8M7H3SdoMsiLze4WRHWj8BEDX0OzJkE3R0gQNlzorNsorNsQlk2oSy7y7KnYTF47WlbCiFLFAoF3YbZHltmPhXYngDBnvTcCPZkvoUgXCnQnlxvHPuWCS9FDqYd0FcJc7MhiUHXRGg+2DlgZxvEq0HPh3y2EXefIGYSZa0kCAF7dpVPdJVPdJZPdC61p2GoaTF47LmwsGBZikKhsPDBbMNVZj5lpRGrATbVWEsM8e+e6Esh+hQ7H+wbJ68i5tvnXe2hs7CwQNmBtd2ZG8LCvb1YkN9XKPOxLF112Plgcwn7UhjnQy6jT3nryTOJslYSBPrMPSDQrvKl9hxuMgw3GYYbDcONHiuPPc1LUSgU2DKrDRdoA+wIhPGxlULsyQWrASrTcNkTu37od4SuDVYN7+oKHaYdWDMxM9Y86ylrhkFsaLHzYY7MmiR2zlyPkZgPCjorFLHzAXtGju1bXrDrx8c7y8c7yye6Kia6KpaeuQ83G4ebqOC1p2kpCoUC+5RZL6TM6suEqwE6Ak3ox560OrkahG5PrpWGvinmekBXGtdKCB2mHVgLRWeLnTbXS+GdDzoZdKHkzAxuhrzzIZcJyxU7H7Bn5Ni+5QW7YZw66hzvKn9gzw0BezYttSfnFUter3dsKQqFgn7EFoSXKbCvYmvQBjShX7Hkj/yZO/pG6JXJhLwSIorX66XswNrurI3ONTHWuwh95lzzGUNWGroOyZkZ3NzI8+Etk6cdxEyirJUEYfuW5+2G8YmuiomuB8eeG9atVGxYy/q7Z5PHoiVcLe/1ejVLUSgUzALrKV3mgtWGawTecViNBdpTQTwxVyBHo0F4k2BP7PtirUnm2uB912GHaQf0Va65YRugT8M7H9Yi0KVwrVu0Y7jmI2STcS1X7HzAnpFj2xJ7Bo49N6xdGbhTUz/UqB9q1A826gcb3RYt4U5Nr9c7shSFQsEqsMqEl1h9mU+ZiB12ZGSEbE9UnVgibU/yemCtE941EAmYdkBf5Z0MayNi31G45kMPzrUsQi6xXgrjfMhl9GnQgD0jx3uvP2c3jI93lY93lY91lo91lvs89g1rVyjWB+5zb6TDbdYSviXE4/EMLUWhULAKrDLhJUIz9CmhAdqSfMUSU4goqGQJbUKxJ9cbIbwv3lUUXjweD2UHdLsLmQz6vghvLZT5MDcNa4mE6ZEnH8p8CIsWPqUgZhJlrSQI723eaNOPjSnLF6PM57GvX7tCsX7N8oV556y6ng6XeYrrG+qOp+a43e7+pSgUClE1XGXep0Ia0Ai/Wj46YOeDvhGqgD4KX9Xhxe12U3ZAtzu6dML0hLyX0OdDXhB5iWGfj5CcD+Pmo2YSZa0kCO9s2mjTj2mUZZqOQCz+IvHq5Xe9zun++uk+Kuqcpimub0emsqSXgUKhoB65oNuwYDYQMho6DtqdiSzsyXzXzHfEfGtoQcjbDxdMO6CvkrcXqwFz2kFPnjyfXo7VQsjDXo5UDHE+QnI+vJsP7Bk5tr72rFU3pmkv1bSXjrSXjrSX+tx2+rvlnYvqrJ/uq3eaprh+meN4ao7L5VLJAVnYM9YriR+Xy0XZQSLbHeZDnkmUtZIgvP2n31l1Y8NtpcNtpcNtJUNtJfOUPZ9a/ehdr2Oqty4QqjqHcYrrV+GoLOmWA1hbSS1ivZL4Ydoh3nPp7ob58M0kylpJEP766r9adGODrSWDbSVDbSVDbaXzbvvib2p6HVO9ddq+WkqgDtMkas/jsf7SbLERczMKiZivJQgICGZQZ4qoPa26saHW0qHW0qG2UrY9tX312t4HZ+5Ye8bwtDcIYm5GIRHrlQQAwANI9tSPD3eUD3eUD7eXDbeXBey5+F+jhml143R/44y60WnWon/3BHuCPQEgvuGy59t/+p1VP65RVmiUFZqOCk1Hhc9D/9do3jmjbpxRN84ONM0MNDrNWvR/7mBPsCcAxDdc9tz62rM2w8RYV9VoVyUVPo/j6TXLFU+vWb4w75wZaJoZaJodaJ4baHKZtVs3gT3BngCQWHDZ851NG+2GifGu6vHumvHumvGuGp/HsZ625+xg8+xg89xg89xgs8sy/Q7YE+wJAAkGlz3f3bTRbpyc6Kmd6Kmd7Kmd6Km963WsX7OCPvZspgXqskzHwbEnAACAKAj2dBgnJ1W1E6raCVXtJNOed+ed04tn7rNDLS7L9NZNsv+vEQAAgCg47bl5o8M0NdVXP9VbN9VbP9Vbf9frXL9mBXXFknNK3ahVN04PNE4PNDkt2rdfk/0VSwAAAKLgs2fDVF/DEnv+bPUyn9c52d+g7W/Uqpu0A00Os/atP/0W7AkAQEJBtKdW29eg7W/U9jVo+xoC9lz35DKf1zHe3zDR3zCpbphSNzjM2r+8+i9gTwAAEgqCPZ0mrba/UdvfqO1v0vY30vZ8xOd1jPbVjffVT/Q1TPQ32E3aP7/yG7AnAAAJBc+xZ38THQF7rqXs2Vs31lc/3lc/3l9vN0298co/gT0BAEgoSMee5ulpdfOMunla3Tytbr47v2jPea9D01s32ls32lc/1ldnN01teRnsCQBAYsFjz4GW6YGW6YHm6YGWu/Muhj1VdaN99aN99WN99TbT1JaX/zFEe8b8QnSIxIwI7FNAokCwp8s8MzNwnY6Fpfas11D27K+3mbRvhHzsGfO9CCIxIwL7FJAokOxpmZkZvEHHA3v6vI7R3obRvoax/obx/ka7SfvmK/8M9oSQYxw8mgkBwYpw2HN2dugmHQF7rnvyEZ/XOdrXONbfON7fNNHfZDdr//xqqP9zj/leBJGYISpLgUQgfPa8NTd0a3bo5uzQrYA9qavlJ/qbJtTNE+qWSXWzwzwd+tXyMd+LIBIzxO1YMcXpdMZ6CjLD5/NNT0/rdDqLxWJjYLfbqUcah8PhdDqNRqM/XPa0zs4N354bvj03fGtu6NbCvPvBnZqT6uZJ9fXJgevawetOy8xfQ75TM+Z7EURihqgsjS1gT7HE0J5u69zc8O25kTtUMOw575oavDE1eEM7eGN68KbTMhv6t4TEfC+CSMwQlaWxBewpltjaUzfSqhu5oxtp1Y20Lvjc9HcsuaYHb04P3qLCaZkN/Rvq5J7ZgPSRe445HI5YT0FmxMyemza6rXM6TSsdD+y5MO+eGb49M3x7Zuj2zPBtl3U29G9HlntmA9JH7jkG9hRLLO1p0+k0bfpRKtpZ9mydGW6dHb4zO3wH7AnIArnnGNhTLLGy5zubNrptOv1ou360g4oFn2fxlzl87tmR1tnhVurRZZ2LyZm7QqHgqsS+JKQ7toGQ0QDpI3d72u32sIwjPPPlDpc9XS6Xx+NxuVwRs+ezbpueVifbnnOatrmR9rmRtrmRNpdVF/pvapIzW8GAWYmOQ9sT2wVtia0XsiBAdsSrPRXccA1FTum4SXisPZ1Op8fj+fnPf84UaHjtufW1Zz02vX6sQz+mNIx1GsY6F3yexd/U9HnmNB2zmvZZTfucpj069mQWuFIEe+DJJVlyqrGGFZKRgMSRuz1tNhu2nuuTHk1pIZIVZWGJg9qTUudjjz32D//wD5s2baIFGn572vX68S79eKdhvMsw3rVoz9XLF3yeuVHl3KhyTqPUaZQuq37raxG5Ymnet0CFQqFgFtBH+lUu6DasLlyVrCWS+0LIIsg5JvG4f/9Hnd5479599CXWLoAto0+FdCF3lH6w7Empc9WqVRs3bty7d29qauqRI0cogYbbnr/z2A3GiW7jRLdhots40X3vrufp1Yv21I116kYD4bZJwp60JVHxoflBSCysdrG9IOQV8rengcueQR80zHPsXLy9ZBEse3o8npdeemnPnj3nzp0rLCysqqpqamqqrKz0eDzht6fDaJzsoePeXe/TqxfP3HVjXbqxLt1Yp26s020zROjM3Tt/lwpmQlBPWY90M1ZjZi9WMBtzvcr1FEKOQc4xicf9+z/OzukW7t1HX0J3AbSMPiXUk3cNGQX22BMlAseez3ocRuOkyjjZY5xUGSdV9+566b97evXjPbrxbiqiY0/WdvVy25OcK8wGhHziNTWE7ALsyQU6YHykeqyuWNr62rMeh8k01Wea6jVN9Zqm+hbtuXr5wl2vfkKln+jRj/foJ3rcdmM07UnY/KzPTFa98DRijkAeCkJGIWt7/vjjjzOzc1z2FKJFrtRlCVegYWURMbPnpme9TpNJ22fS9pm0/SZt/wN73rvr1U/26id79ZMq/aQqcvb0eH1UKBQKVoFV5nqV2vDMSrqe1ZfZBV0idgIQ8gpyjkk87v/44/TM3MLCPfQlrp2Clavk1BWya8guYmpPs3laTce9u/MP7GmY7FuMXo/DFAV70jA3JzY/mHnAlRC8KcIlTZmmEYQnse0pPG/BnmG5Wt7rNFtmBhZj8N7C/Po1yxVPrV5+7+68YUptmFIbpvoNU/0eh+ntP0XEnm7PPBUKhYJZoJ/yllkdma9iwQ6FPoWQY5BzTOJx//6PU9qZuwv30JeE7w5CgnfXkFHE0J7zLot1doiO+5Q9f/bko/fuzhumBiiBGqfUHof5r3+KyBVLLrcXDYVCwVVDFaiNzSwIGYRVySpzjQMhoxCeYxKM+/d/nJya9t1dYNVzZTIzaUVlL++uIaOIqT2t1rlhOu4v+Bj21A7Q4XGY//pq9OwJARFcyDrHuOwJQQifz9fR0XHt2rXTSzlz5gz1SHPlypWurq7w2tM2N2KbG7HpNLY5TcCe61ZR9hwyaoeM00PG6SGP0/JWZOzpdHkgIMIVss6x+/fvT0xqfb6FmM9ERuHz+a5duzYzM+NdhLrA02KxmEwWo9FkMBjn5nSTk1M9Pb0FBQXhtKfbatNpbDqNTTdq043S9lx27+68cXrYOD1smh42zQx7nNYI2dPhdENAhCtknWP37t8fn5ia992N+UxkFD6fLy8vj/am0+myOxw2m316enZyUjs2PjkyMqbq7b9x805fnzonNyeM9vS5bXb9GB0Be659Ytm9uz7TzIhpZsQ0O2KaGfG4rH95BewJIfWQdY6BPYMIyp70DUV2u8NqtZnNlrGxyeHh0YHB4b6+gdY2ZUvLrZ6e3jDb02N3GMbpuH/v7vo1yxXrnlh4b8FnntWY5zTmOY15VuONmD3VABA+IMcSDdqebrfb4XBS6jQYTMMjo2r1kErV39mpunOno7n5Zne3Kvz2NE7QsWjPVcvuLfjMc6OWuVHz3Kh5btTrsv7llcj8piYAhBGZ59jCwkKspyAzYm3PSYdxwmGcdBgnl9jTohuz6sYsujGLbszrskXInoeujUFAhCvknmMHr8Z+DvIKpj3dbo/bTX0hiFOnM8zMzGm1MxMT2r6+gcjY0+EwTTpNU1QE7PmzVcvuLfis+nGrftyqG7fqxr1ue4Ts6fT5/7f/RQGP8BiWR7nn2P/+v8Z+DvJ6ZNrT653/77/61Vt/+csne/ZQkZWZWVxUpNGMR8ietDqdJu2iPZ9cdn/hrs0wQYVVPzEfMXuaPX4IiHCF3HNM54z9HOQVLHtuffvt7779tmSRhoaG9vb2SNnT63CatU6z1mWedpqnA/Z86slH79+7azdO2gyBmHfbI3TFksnth4AIV8g9x+YcsZ+DvCKGZ+53vU6XeToQlukf7y0w7Tm1GJPzHkeE7Glw+llB34JGP0XbCAnWOJIKdG5Snq2MQmCOSTZmbJwvYXODN2eEZJSssy6GZ+53vU6XZYaORXuufvT+vbsOk5YWqM/jiNCdmnNOPzMUCgWrJrgI1zjhCuZ80DLXqxBiQ0iOSTmmbJwvcSVGdBImuKVEYW4xPHOn7em2zLgsswF7Pr16OWVPKuxGrc/jeDsy3xIybfMzQ6FQsGqCi3CNE66ZMB+5XpXazOUYQnJMyjFu5nyJOszE1kdhYsEtJQpzi+2Zu9s6S8eP9xn2dJqnneZph3nrMEXQnpNWPx3ML8ti1rAaEOq5xmG14RoHDSG9BA7CaoPtRR4Hgjd4c0zioTHh6+nEY1WycjLE/YKrGddeKXBx6ODkcURFLM/c511u25zbOue2zbltc4v2XLP8/oLPqhu16katcxrrnMbrskbo25FHzX5mKBQKcg21orENmPW8bagCujixvbBLR8dBp807Z4ggQkiOSTkGDfh63sRDH1nNsL3IbQiVYdwNQ0x7lj0PHjhQXFTUuMidO3dUKlXErliyOxdvNHLS9xo9vWa5z20baS8eaSsaaS0abi20zmkiZM9ho58ZCoWCXINtQMPbi9AGDYEjo23QRTMfeScGEXQIyTEpR78OX4+mGavAlWbB7QhoPvPuhsxJCl966GkfwzN3h3FCq6qa6qnWqqq0quq7XkfAnh67QVmepSzP6ijP7CjL1I91RcieAwY/MxQKBbmGtwG5F6uA7cu7LGY9eQRsM7QscBAI3hCSY1IO1Ry+niuBB5amEG9+ot3RNth64buhqKWHnvkxvFPTrO0dbDw72PTVQOO5weZz807TA3t2lGW0l6a3l6a1l6TqRpURsme/zk8H8wOWVYN9inbkGoeuZJVZlaxhWSNjexFmRQjChEWNA8EK3hyTeHTPYCqxqduPSxvmYz9x92EVsPnMSkVCF0JHwtOwJHxs7aluPDPQcEbdeEbdcGaJPWl1tlH23BQRe6rm/BAQ4Qq555hyOvZzkFfE2p6n1Q2nBxrODDQu2nM9dexZmt5RktZektZenKobVb4TGXv2zPohIMIVcs+xDm3s5yCvoO1Jfbmn2WwxGk16vWFwcKSvb6C7u7ejo+vW7bbGpuuRsOdAw2l1Q0CgS+ypLE2nBNpRQtlzYyTs+cR/U0xY/fAIj2F5lHuOjZpjPwd5PVL2dLvdlDoNBqNOZ5id1fX1qbu7VR3Krjt32q/fuN3Q2BJ+e06pBhpODQTseZq25wqP3dBZntFZlt5ZlqYsTdWPKd/dHBF7xvwbriDiKeSeY/ANdWLD5/NdunRpZmbG4aC+Vd5sMpmNRtPY2PjIyOjwiGZoaHhgYKi/f6CtrSM/Pz+89lTXnxpoOKWuP6V+YM+1Kzx2Q1d55qJA0/Vjne9tfi4S9hQ1AgCQkXuOmdz/X6ynIDN8Pt+dO3cuXbqUk5tDjvz8/Lq6unDbM48S6INjzw1rV3gdhu6qzO6KjO6KjO7ydMN453uvgz0BqSP3HAN7iiWGv+e+aE9KoKfnncYH9lRVZakqM3sq0nsq0o3jndu2PA/2BCSO3HMM7CkWadgzb6DhFH3sudLrMPRWZ6mqMlWVmarKdON453awJyB55J5jYE+xxNiedXm0QBePPdet9DoMquos1aJAjROd27e8IEF7UlfbhjgZtpeLAAAgAElEQVQIEDfEqz2ZF6L7GWnPzH9sGyE1fjnvR7E+9swdqM9T1+c+sOcz6wLHnr3Vmb1Vmb1VGcaJLmna0+/3B73VZZouAIG4tCczUZmuRJ+iL3E1A3sKHJ9ozx51fa66Ppc6Al1iz77qzL6qzN6qDFVVhnFcoseefrAnwCDu7cmqxNqT0BftBfYkw2PPupyAPetY9qzK7K3K6K3KUFWmR+fMnetEw7906zLr0afMSq6RuXqhoF24Bhe1KoAIEZf29HPkGDnnCW3AnuG0Z10Odf6+9My9KiP69mR14TrjCLpAXpzApbPUKXA0IArEqz0psAeSotqgx55opbyQiD3V9bnzDtSelem90bKnH3dY5+ewFVpDlib2+JQ8YfSIFe2FbQPEivi2p59vX+BtQ5CpTBM41vbMpgWKHHtWpvdWpvdWppmi+3dPgvWCtid2ZPKEubqLGgSIJnFpT658E1v2I7sG2JMXgj1NgWPPgECX2nNRnb0VacZxZfT/7klXssZhtkHLzDbkkdEu6Jyx43MNLmptAJEgXu2J3S/QhBfeBuwpcHyyPft57amqSI2OPQEgROSeY3C1vFhibc9s+vAz8HfPwNXylemqyrSeitQesCcgE+SeY2BPscTcnrRAF+25dqXXrldVpKrKU3vKU3rKU4zjSrhTE5A+cs8xsKdYpGDPfurM3UF/S4hdrypP7S5P6S5L7i5LNox1wLeEANJH7jkG9hRLLO052b1oz+x+pj09dn1XWUpXWXJnaXJn6XH9aAd8Qx0gfeSeY2BPscTYnrUnaYF6KXuuX7vCY9MrS44rS44rS451FB/Tj3bAtyMD0kfuOQb2FEssr/ek7Lko0EV7rlnhsek6io8GouiITtMeoV/mEDUCAJCRe46BPcUSW3uqa0+qEXsud9t0bYVH2gqPtBUcbis4rNO0RehX4USNAABk5J5jYE+xSMKetScx9mwtONR67VDrtUNzI20R+kViZgPey32jjNTmA/ASx/Yk3M1BGFBIrso6n6Viz9qTAXs+vWa526ZrLThExZ2Cg3MjrVsjbE8Fcn8RWhNpuJYYq/kAYkk0exLqw0twS4nC3GJtzxOUQNW1J70OA8Oe1wIHnneuHZwbad36Wjzbk3zLGthTLsS3PbkOPyM5o5CWEt/2NHHbc27x2DOpVfLHnujNvH4k24Sc46BtsL1AnZIlXu2J/Vxn3bHO9YcmtD15v0CbYZ9yjY+dHrYN1ziikIA9AwKdR+yZ1FqQdKcgaU7TJll7MjcGb3fyOFxbUeBMgJiTOPbEZjvvjoPdEbjaECqxWhQ+MirQoIn19Z4naIGy7BlQ552CpLmRaNiT+VmErcHC9YnK24bVwI9LPtZooE6JE8f2RA8AmYUw2tNPlCNXF//SHVbg0kPfoWJuT1qgAXuuX7PcbZtrK0iiBNp6LSkK/3NHP44EfkBxyS6IA0auLrwGByRCHNuTXAivPXnbCDzCiH971pygBbrEnvT/3CV1xRLvhx5a4BqKF/TTHj0EACRFXNoTTUJmmZX8/qVuwrb3I7sJdk9B3cfVhdCR8DQsu5JE7NmPt2cUr/ekIGw2ACATl/YECMTenjU4e7YVHqIvWoqmPQEgaOSeY2BPsUjCnjUn+mtPeJf+3fNQW+DYMxp/9wSA0JF7joE9xRJre2bRAsXYs60A7AnIBrnnGNhTLNK0p27RnlH6nzsAhI7ccwzsKRYJ2DMLa8/DbQVJVIA9AVkg9xwDe4pFGvbMAnsCskfuOQb2FItk7Rk4c28rSNJpwJ6ADJB7joE9xSIZe2bh/2sUHXui1/GKQlQv3ut+pQnhwuYYzkpSxLE9sVuZd+sLyQ1Z549E7dkeXXv6Q74hUlRH5g0P4Roz7LBEySpzvZrIJJo9CfXhJbilRGFuUrVn4aH2woBA49KeQhYXKysx54a9Jc4P9sQR3/bkOvyM5IxCWgrYM3r29PN93QvX2T3v3bVcXfyIg3jPi4WcKQufM+8gQpYO6qSJV3tiP0eZGaJgwGqAtheyp6A5LDaleROYaxxRSNqelEBjZU/mio5EgbUt0TnwzgeFsCyx43BlFWGGCU7i2BObXYRm2F7kNoRKrBaFj4wKNGgka88kOuRlTz/u0xJbCMKeBKkR2ogdh4tnIEwV8Me1PckpHUZ7+pfuF+RxsJMUvvTQEzim9uzqr8mkY8kvc7QVJtGhi/x3y1OExZ7hKhDmQ4BLduR85R0KLYM6UeLYnuRCeO3J20bgJ3oc23PrpmdNk119NZl0eB2Gp2NoT+zhGFcN63NYYA26INbG5v0cRodF3ylrfFaB8GbJEN5j6FkYH8SlPXnTmJXM2Dz3E9MSm5kKjj2RK+WwHQlPw5K6UrSnxzbXXnQo+seeABAKcs8xuFpeLNK0p27xX0aBe40i/YvEABA6cs8xsKdYYmbP1541TXT1VWfSsdSeRYeogGNPQC7IPcfAnmKR3LHn+jXLPTZdZ/ERZfGRjqLD7YXRu2IJAEJB7jkG9hSLFK9Y8th3XSVHO0uOKouPKIuP6DXt72zaCPYEJI7ccwzsKZbY2XOjebJb/eD33B/8rtEKr13fU368u+xYd+mxrtKjhtH2dzeDPQGpI/ccA3uKJVb2fHfzRvNU90D9STrmnYb1a1Yo1q9d4bXreytSVBUpPeXJ3WXHDWMd721+DuwJSBy55xjYUyyxsud7m5+zaHsGG3LomHca169dodiwdoXXoe+rSu2rSu2tTFFVJBvHle+9DvYEpI7ccwzsKZaY2fP156xa1XBjLh3zTuMGyp7zDr26Ok1dndZfldpflWqaUG7b8nyk7Rm5a7/Ri4pDWUqsrk4nXNgc/clIkzi2J3Yr8259Ibkh6/yJlT23bXneqlVpmvLo8C3ac+W8wzBQkz5Qk0451DSh3B5he7KkIGpkMlwjh7KU6CQceeaRW2PyJdHsSagPL8EtJQpzi5U9t2953jbdO9p8ig6f07hh7cqAPQdrMwZq0geq09XVaeaJzmjaM7xEIu0inRZMP2JvifODPXHEtz25Dj8jOaOQlhLX9nzBNt072nKaDp/LtGHdoj2H6jJpgUbBnn5ht5nTNegNs6wys4CdD3lZ6DispRPeqfBxeAfBvnfeN5KwxKs9sZnMzBB0p/Bzpy45D7n2L7EpzZvAXOOIIrb2HGs5TYfPZXpm3YNjz8zBmgzq5D06f/ekYG2A0AtcGwbdrkEUCMMSpiFwHK6swg4F+BPJntjsIjTD9iK3IVRitSh8ZFSgQSNBe1L/NUrvr07vr0rrq0w1TUT1f+5kW6EfceRC9O2Jig+bfITU4doZhE8jMYlje7ISJnL29CO7GGEc7CSFLz30BJacPamr5XsrU6lLPlXlycZx5bsRvtdIlBCZiLJncJtWrD2xNeR85R0KLYM6UeLYnuRCeO3J20bgJ3oi2vPpNcs9dl1nyTFl8VEq9Jr2ra/9LtL2xB6OoZ9m2I848sEd+rkd3DjYkdF3ii6a8EYErTtcF653kcjEpT3Rjc4so9mINkCfcu0afgF7IlfKYTsSnoYldSVnz6eefNRtnbt9NSkQVw7OjrS+9cq/Ru3MnQBrS4jtDsQ3cWlPgIDk7PmzVcucltmmC583Xvi88cLnTRc+1w7efvOl30jBnv4wfWQBcQnYM9GQnD3XPvGIwzxTdW5P1bk91V9/Uv31JxPqm6//4Z8kYk8A4ELuOQb2FIvk7LnmsYftpunivA+L83aWnPqo7PSusd7rm37/P8GegMSRe46BPcUiOXuuXvlTq1F79cT7V0++X3Dyg8KcHaOqlj/9+/8L9gQkjtxzDOwpFsnZ88mVD1kN2ksZ2y9lbr+S9bdrJz/Q9DS/+u//A+wJSBy55xjYUyySs+eqFQ9Z9FM/pG27mLH9ctbfrp58X9PT/Oq/gT0BqSP3HAN7ikWi9sxP23YxffvlrL9dywZ7AvJA7jkG9hSLVO2Zvu1S5n9dOfF+Qc4HUfi7J/ZSXiwSv2KJcPlxDGeVIMSxPbH5w5tXQrJO1pkpRXtaDVOXMrdfOfG3gpwdxXk7x3qvv/YfEf+fO/MmBK5BhLSJMlwX8LNu/PBLac7xSqLZk1AfXoJbShTmJjl7Uv81unLybwXZHxTn7Sw9s2u878am3/9jdOwpRJ0SgTlh7I1rfrBndIlve3IdfkZyRiEtJTHt+VObUVuYu6P41M6yM7sqz308qb75+ovRsCf2llhmATsyevMsOlpwvQQOwmqD7QXqjALxak9s/qN/7CJnr5A22GbYp1zjY6eHbSN8VyUgOXuufuxhu3G67PSuirO7q87tqf12r3bg1pY//nP0jz2ZK5r1lLnqsY39RGFxNSYsnWscrm2PHQqIKIljT2zeEpphe5HbECqxWhQ+MirQoJGcPdc8/rDDNFP99Z7ab/bWf7ev8fxn00O33/zPiN/nLtye6EvkAgr6AYu2x7bhmjDaRsg0gPASx/ZkpWLk7OnHSU2gYXl3KMI0gkNy9lz3xCNOy2zj+c+aLnze8sMXNy59OTvc+peXfxsde0aigMIluyAOGLm6cFkViBxxbE9yIbz25G0j8FghEe35syeXuaxzty4fuH3l4J2rSW0Fh3Satr++GtlvqGN+cLE+Y9FPXexBIlrDHBCdD3aJ6IcnOjgZ7GyDGAcIgri0J1fyo6nFynauVPQjCY/Nea69jCuZsR0JT8OyU0jOnk+tftRj03UUHVEWH+0sOdpVcsww1rH1tWcjfewJACEi9xyDq+XFIjl7rl+z3GvXq8qTVeUpvRUpvRWppomI/zIHAISO3HMM7CkW6dkz8KtwaerqdHV1+kBNunmyM5q/CgcAwSH3HAN7ikVy9tywdsW8wzBUmzlUmzlUlzlUl2mZ6oraLxIDQNDIPcfAnmKRoD1XzjsNw/WZw/WZI/VZI/VZ1qnu7WBPQPLIPcfAnmKJtT1Pse35zLqVPqdhpCFrpCFL03BC03DCqu3evuUFsCcgceSeY2BPsUjAnqc47UkJFOwJyAK55xjYUyxSt+dIQxbYE5AFcs8xsKdYpGHPUzG2J/bSX0KNqEVHE8LlxzGcVYIQx/bE5g9vXgnJOllnJtjzAejtDbyFmMMSJavM9SoQCRLNnoT68BLcUqIwN8nY85TPZZSiPbECkoKJmNPD3rjmB3tGl/i2J9fhZyRnFNJSEtie9ZKwp5CzYPTmWT93tonqJXAQwny43hoQCeLVnthPaN4/anHtO+QMR5thn3KNj50eto3wXZUA2PMB6LpmVTJXPbnAaz3eXmgb7Dhc2x47FBBREsee2LwlNMP2IrchVGK1KHxkVKBBI2F71kvCntgaQgHbER0H+znM2wadDJeshcgXCC9xbE/0AJBZCKM9/UQ5cnVhTlL40kPfNaRtz3pJ2DOIgsBjT1ZNEAeMXF2ETAMIL3FsT3IhvPbkbSPwWAHsmTVSL/UrllifyczGdCU6H3RkVi9WG4GwuqDvAogccWlPbHr7OXYQ/1I3Ydv7kYTH5jzXXsaVzNiOhKdh4SnAngAQHuSeY3C1vFgka8/MB/acAnsCMkDuOQb2FAvYEwDCg9xzDOwpFinbMxPsCcgIuecY2FMsErdnJtgTkAtyzzGwp1jAngAQHuSeY2BPsUjfnplgT0AWyD3HwJ5iAXsCQHiQe46BPcUiC3t2SdOecBU6wCSO7YlNct7kF7JryHr3AXuGiqw3PxBGEs2ehPrwEtxSojA3sGeogD0Bivi2J9fhZyRnFNJSwJ5RtSf2ll70Blv0DlxR4whvgyJ2ZCCaxKs96TRjVZJ3DexT3lxFm2Gfco2PnR62jfCdjgDYMwBztTILrE3CKvhxWYUWgmiDEvQMgeiQOPbEZiChGbYXuQ2hUsgOJWTpoXiTAuwZgOuzkdUGrReykViTwX7A8r4FgTPEfuoCUSCO7cmVrmG3p58oR64uzEkKX3ro+wjYMwB2K/o5tnTo9uStQRE1QyD6xLE9yYXw2pO3DWH3AXvG+O+edBKwCqwGzKfohx5XF8KyxH7AYmdIWCIQaeLSnmgyM8ushPQvdRPXjkDIfOwORe5C6Eh4GpbdBOwpAlASQCAu7QkQAHsKBY7pADJgz0QD7AkA4UHuOQb2FEtM7akabckDewJxgtxzDOwplpjbkxYo2BOQN3LPMbCnWMCeABAe5J5jYE+xSMGelEDBnoC8kXuOgT3FIhF7jrbkgT0BeSP3HAN7iiXG9mzOG22Whj0JF+6ynhIu7kUvIZYFvO8dEEIc2xObCbwZIiR/ZJ1jYE+/H3eDF1qDFrh6oa9KDey78xPfO8BLotmTUB9egltKFOYmOXtuWLdy3mEYrsugwzrVtX3L8xK3JxMpG4fsd7BnKMS3PbkOPyM5o5CWkij2bM4bbabtuXblvEM/VJtOh4Wyc5tk7Mk6l8cuCz0F9iP5h/2bANoMHZnVizwyYRBWG2wvUKco4tWe2M9aNGnJeSikDbYZ9inX+NjpYdsI3OPISNCeK+Yd+oHqNHUgUs0Tyvdef04i9mSOybXSecWEDsi1CCG9hEwVnQ+2AXYoQCCJY09sBhKaYXuR2xAqhexQQpYeijcpJGRPp/GZdSsV69es8Nr1vRXJdBjHle9u2hhpezI/i7A1fmFbWmAz9BOVMCCrCzlFCHL0cyc6azRQZxDEsT2x6erHpVOI9vTjpBbEDiVk6aEnueTs+fSa5R67rqvkaGfJ0c6SI53FR/Sj7Vtf+110jj2xxhRiT1Efp1xpxGtPbA05F3mHQsugzuCIY3uSC+G1J28b4TuUwHcRNNKz5+rlbttcW0FS67Wk1msH71w9ODfS+tar/xpRe/o5PrtY6sR+KgbRi1kvRM3YwdECeYkEuOYsdpwEJy7tiSYGs8xKSP9SN3HtCKwCNnvR3YGrC6Ej4WlY0lty9nzqyUdd1rmbl764cfGL6xf3X/9h//TQ7T+/9C+RticFYbNFGvCU3IlLewIEJGfPdauWOS2zjef3NZzf1/D9p/Xf7Z1S33zjj/8cHXvGBDjEiw+knGNCAHuKRXL2XPvEIw7zTO03e2u+2VPz9Z7qrz+e6L/x+h/+KY7tCcQHcs8xsKdYpGfPxx9xmGcqz31c+dXHFWd3VZzdNd57ffOL/wj2BCSO3HMM7CkWydlzzeMP203T5Wd3lZ3ZVXb6o7LTO8d6Wzb9HuwJSB255xjYUyySs+fqxx62m6ZLT+8sOb2z5NTOklMfgj0BWSD3HAN7ikWC9vypzThdnLezOO/DkrwPi3M/HFU1b/qP/wn2BCSO3HMM7CkWqdoz98Pi3B3FeR8W5X6oAXsCckDuOQb2FIsk7WmaLjn1EXX4WZz3oUbV8pok7QlXGgFM4tWe6FXxCuQ2DWwbITV+Oe9HErTnw3bTdNnpXaWnd5Wc+qgk78NRVYtkjz2D3uoyTReAQFzak3WvDrPAeoq+xNUM7Clw/OD+5z5T8dXH5Wd2l53ZVXrqo9FesCcgA+LenqxKrD0JfdFeYE8yQVzv+bDDPFv9zd6qrz+p/Orj8rO7x3qvR+F/7lwnGv6lW5dZjz5lVnKNzNULBe3CNbioVQFEiLi0p58jx8g5T2gD9ozsvUZOy2z9+c9rv9tX883eqq8/mei7EYWr5QnbPlwF8uIELp2lToGjAVEgXu1JgT2QFNUGPfZEK+VFrO2Zi7nP3WWda7l4oCn/i8YLn9d/v29SfWtLVO5zRw/r/By2QmvI0sQen5InjB6xor2wbYBYEd/29PPtC7xtCDKVaQJLwJ657O9Yctt0t68dvnU16cblg9cvfTk9dOfPL/0mCvakIFgvaHtiRyZPmKu7qEGAaBKX9uTKN7FlP7JrgD15EWbP3CXf7+mx65UlyR3Fx9oKj7YWHJ4baXvrld9G4cyd91iP2QxbZrYhj4x2QeeMHZ9rcFFrA4gE8WpP7H6BJrzwNmBPgeOLtuf6Ncu9DoOqMr2nIq27PKWrLMUw2vH2nyL73fIAEDpyzzG4Wl4skrFn7qI9166YdxgGak+oa7L6azL7qtJNE53vRPh3jQAgdOSeY2BPsUjOnhvWrph3GocbsofqswfrTwzWnbBMdkf6NzUBIHTknmNgT7FI0J4rfU6jpilX05gz0pgz3Jht1XZH+vfcASB05J5jYE+xSM+e61b6XMbR5rzR5lxNU66mKceq7dkO9gQkj9xzDOwpFsnZ85l1K30u41jLqbGWU9SlTLZp1fYtL4A9AYkj9xwDe4pF0vakBAr2BGSB3HMM7CkWsCcAhAe55xjYUyzStKeJtudYy6ko2FP4hbtCLoPnBb1sOOihwgLvpc6AEOLVnth09ePuECGkNFeNH7kBREZI1p6nGfbslY49WTCzR2wXbPfopBF2Dn7cGpBpWseEuLQnIV2xSYvuSlxJDvbkBezJ2QWtjEIOkd8p2DMU4t6erEre5GfVo73AnmRCsefpqNnTL+bWXd5eaIH3wxZdFhbysrgmiR0EOwG0JXk+AJO4tKdfWG4IbwP2DI89tfz2PB1Ne/qRj1NWpR+XEKwFYcXE2xddEAo6DmF6hKEIpia8U4CXeLUnBW/m87YRuIvJCOnb87Ts7ImtIWebkOxRMCDMh3wYS05ZUfMBWMS3Pf3CPlyF7yxgT17AnoFKrJi4DiexCPGywCzk6iLrVI45cWlPcqoIL/uJO5dMUy7G9mzKHW2Sjz1Zh3XYI0HscR+2DToOl2Sx46MF8hwICJkPwEu82pM3z8W2UYA9hUG0Z0/Ank0SsCcAhIjccwyulhdLrO2ZM9qUg9rTCPYEZIfccwzsKRap2LMJ7AnIHLnnGNhTLNKwZw5qT+pSebAnIBvknmNgT7FIxp45YE9A3sg9x8CeYgF7AkB4kHuOgT3FInF7Ru9OTQAIEbnnGNhTLGBPAAgPcs8xsKdYwJ7BAxeTA0zi1Z7oVe7obRrYNkJq/HLej8CeIRH0VpdpugAE4tKerNuHmAUF7r44wn1EaHewJxmwZ5g7ApIl7u3JqsTak9AX7QX2JCMbe3KdaPiXbl1mPfqUWck1MlcvFLQL1+CiVgUQIeLSnn6OHCPnPKEN2DM+7cnqwnXGEXSBvDiBS2epU+BoQBSIV3tSYA8kRbVBjz3RSnkB9nwAeljn57AVWkOWJvb4lDxh9IgV7YVtA8SK+Lann29f4G1DkKlMExjsyYZgvaDtiR2ZPGGu7qIGAaJJXNqTK9/Elv3IrgH25EU29hRyrMdshi0z25BHRrugc8aOzzW4qLUBRIJ4tSd2v0ATXngbsKfA8WVjTwAIEbnnGFwtLxawJwCEB7nnGNhTLGBPAAgPcs8xsKdYwJ4AEB7knmNgT7FI1J6jLXlgT0BeyD3HwJ5iiaE9rWR70gIFewKyQO45BvYUS2ztqWnKxtnTaRxtBnsCMkPuOQb2FIuk7UkJFOwJyAK55xjYUywxtyctUMSeiwKN4dXyocN1kbzAZcGV8DIiXu2JXuWO3riBbSOkxi/nJJeCPSmBxtKerHskRI3MC3ZA4UuRaWIlIHFpT+yuwbpBCG2DvY8I7Q72JBOaPZvzRpvzbNOqaNoz7IA9E4S4tyerEmtPQl+0F9iTjEB7apqyY2lPP8cmRCvRsxW0GfP0BH1KV6LtsctCWwpZOrkNitiRAZS4tKefe9cIrg3YMw7tScGShZAClxYJBT8usYIu8M6ZNzWDGxlgEa/2pCB8/Atsw0oq5lOZJlWM7dmYrWmUkj39iHewx18ElRBqQrcndj6scXhniBLcyACL+LanX9i/B4QkOfMp2JMA0Z7dmsaTkrCnwIMs8uGk8F5oM1GHnKxe5JwWaM8gRgZYxKU9uXJAbNmPZDLYkxfZ2BN7YEU49iQcizHrsWVWX7TMNStsS64ZYufv5z7nEjUygBKv9kS3O1daCmyjAHsKg2zPkYaTI5RAGyVz5g4AwSH3HIOr5cXCsqfT6fTgcLlckbJnA9gTiAvknmNgT7Gw7OnxeH7xi1+sXbt27dq1Tz311K9//eutW7empqZ6PJ7I2PMEffgJ9gTkjdxzDOwpFuyx50svvfTGG2/s3bs3Pz+/qakpUseeU5Q9AwJl2TMX7AnIC7nnGNhTLOjfPSmB7t69+/Lly0qlklJnRP7uyWdPKsCegDyQe46BPcVC2VOv11utVlpNLpfL4/Fcu3aNVmck7GmZ6h6uPzFcHxCoz2kAewIyRu45BvYUC2VPk8lks9kcDNxut9frdbvddI3T6XS5XGG1Z9dQXdZwfRYlULAnIG/knmNgT7FQ9rRarZQfCbhcrjDbc7JrqC4zIFBue+aCPQFZIPccA3uKhbKn3W5HXUkbk0l47TlYm0kffsbSntjLd9GLe9GX/MjlvrwXEmMvLWbBu3RsG4HwXtgMBEcc2xObG7w5IySjZJ11lD1RUbrdbuqRRRjtaZ7sGqzNGFw8/JyXlD2Z9ehTrpslsH2FFFC4GpMXQR4KWya8X0AUiWZPQn14CW4pUZgbZU/UklyE1Z6dg7UZg7WZ1Pn7Uns25Y42SdGeZG+G3Z5CZCdwELQZ2DO8xLc9uQ4/IzmjkJYSNXsaxeAPnz0HajIWBbrUnhrq144ibE8fAIQPyLFEwy6esNlzonOgJp0W6Lwj6vYc52NskampqRs3buTn52dnZ2dnZ+cwQGsAsWQvJT8//8aNG1NyA5tjsZ4UECRaAcTQnqaJTnV12kBN+mBtxmBtxhJ7jjblaJpyNE05o00RtKeQFUQxOzubn58/MzND/T0YiCharTY/P39WbmBzLNaTAoJkbil6vd5oNFosFrvd7nQ6qT9ixtCe5kV7Uoef7GPPKNhTxwe97oxGY25ursfjcbncLpfL6XwQDoeTuhgWIuig1qHD4bTbHVar1Wq1nT59WtSfk6QANsdiPSlAKCYc5kUsFgt1QxH1H3Yp2LO/Ko0W6FJ7NmYv2jPHpo2UPQ0Gg8FgMBqNVIG66tVqtRoQLBZLXl6e2x244T+ItRY1nGnEEoIAABe6SURBVE6X2+1xuz3YQqxnx4PVajMazWaz5ezZsxa5gc2xWE8KCBKr1UodYzqdTqvVSn1fJ33XUMztaZro7K9KVVenqavTB2rSmfY0jDRkaxpzqPN3q7YnCvak1PnSSy85HA4ue7pcbrvdYbXazGaLZMPpdP33X/1q69tvswoHDxxwOl0xnx45jEazTm8wGo1gTyC2WK1Wt9v9i1/8ghKo9OypVFenUTFQkz7v0LPsmR3pY08IiEhHrCUABAllz7Vr17700kuUQCVoz/6qNOr8nWXPkyON2SON2RE99oSAiHTEWgJAkND2fOONN3bv3s38mk6J2LO/KrW/Kk3Nsue80zDccJISqKYxG+wJId+ItQSAIKHs+dRTT+3du/fy5cvUN85Jz56p6uo0dRXLnvUn6J/sAHtCyDdiLQEgSCh7/vrXv87Pz6e/51iC9uyvSuuvSvU+sKfDMFRHfW/dyZEGsCeEjCPWEgCChLLn1q1bm5qapPl3z0V7pi499ly053DDyRE49oSQc8RaAkCQUPZMTU2V7P/caXtijj2H6qjvnT8J9oSQb8RaAkCQSP56T257Ul8cQh4BWrXdoduTgpo361pO+mp5AhaLJS8vb3R0vLn5ZmNjS31DM0T4o765rq6ptrZRpeqV4/WeQDxhXYrM7DlYmzlYlzUUAXuaBUPfsGWz2a5evdre3tHT09fZ2aNUdkFELm7fbv3+++9tACAZmOqUuD31AzUZg7WZ1DcnW6fCbE/0U8XKh91u7+7uLiws/BqIPBcuXKipqQkiNQEgaBx8MNUpaXuqazIWBZplCbc9o/79A0CQ8P5FBQDCRRD5KUV7eh36dXX6QE3GQG3GYG1m2O0JAAAQKyJuz/7Ad4dkDNZmWia7wmhPCAgIiNhGhO1ZlaauTqfO383hsycAAIBcCM2e1enqmnSwJwAACUhQ9rTrF795KV1dnW6e7AR7AgCQaARpz77KVFqg5gmwJwAACQfxlzmUarAnAAAAFl57qrH27K1M6atM7atK7a9KM4E9AQBIPEKxZ0pfZWpfZSrYEwCABESIPdUYe1ak9FYEBGqaUIbRnukZGUIifGsAABKLkydP7tmzZwewlD179pw8eVLUmhRoT3U07enG4fP57t696/V63W53pO2pUChYT1k1aJswLo48E0IDuowdkKpULCXoOQMy5XhyclZWll6vvw8sRa/XZ2VlHU9OFrEyQ7Fnb2VKb2VKJOxZWFbDjDZlz7mLzXuOXB2dmPF4PCx7KrjhbYZtgH3Kgqw8IfPhHU2gslFpspTKelO8byGItwzIhd27dxuNxoWFBSewlIWFBaPRuHv3buErU7g95zH2rIigPTu61VQoewYsVscr2879y2snapp6vF4vak/sUGL3diEHemTQjgRbkcfhGplLxGRTC7cneVkgULmzY8eO+/fvi9KKQqEgPCU3xtbTZWxjqpKVzKImHDT379/fsWOH8JVJtGenAHtWpJjGI2jPTtXApHauqLr7t6+deHtPvk6nR8/ceXUmEC7j8LYkvEpQD9cgtD15a7iWi3UrXSArOOhpA7Jgx44d9+7d4/22NyYKhYL8lAzaES0wx8G+JGRivPW83Lt3L07sqR4em9DOqodGnS73lg+/+93m7PobA5rRUaw9sUNxKYNLsqwaLtGQByEvTvi00QGxbVjzR0fmWjrvGuNtA8gRyp52wSgUCrqAQmhPGJAwCHNx5DGpSq6heKeBJcz2rE5TV6XFwJ632jrbusfOF7ZarNbaFvXGLbl//Tjf5/Op1QOhH3vy1rP8RRYZtg1vmXca2I5cUyK8ir5EWD9i3ykgOyh7CvzCdoVCwSqwynQNF8KHRV8ijIOdD6sZ19IJhN+eiwKNqj3HJ6fe/+LK7zZnd/dr3/nk4vNv5lU1qb1e7+jYONf/3AmeIrTE1nPZk64nm1q4PQlDkQdHNUeYEnmG5DUjpAaQETt27FhYWBD4yzd05rAq0WbkMmsctMBsg46PnRirTJ6VQBYWFsJvz+q0Jb9IHAV7dnarxqcMz76es/GN3OffzPvzRxd8dxfcbveUVsuyp0LY4Ri2kqAzcjN02qJ0RhjHz+FHIa+S3xehgfC3RugLyALKniYxKBQKusAEbUAos8bBNhCyLOxSeNsIJEr27KtM6a2MoD1vt7YbzfaU03XPvZH3wp9PFdeoqIs95+bmuP7uSVaMn0+paAMhksWaUUgZfcqC0JE8beyrzJe4bE4eQeC0AYmzY8cOr9c7JhiFQiGkDReimqG9uJaOtkFbCpk5C6/XGxF7ViP27IukPds7lCMjmgmtIfV0bea5BqfLa7ZYTCazwWDEnrmj/iLs81wvia0XMr5AkwofkOtV4e3JS6dHwxoW1Cl3KHtqhMFMA9ZTqoarPddoXAVmd0IDdCiBbQQSJ/ak8Hg8d+/e9fl8Ho+Hed+R2L97Cnwq0HRRsyeXwtA5i3Ixb3uuV0GdcQBlz5GgUCgU2DKzhvnI1R0toB1Z+S9kJqxm2DmQiao9qQi7PUXd567ggzU+ttIfgnxZY3INzttG4Hy4xiG/d1qyvOuHazTeCQOyYMeOHR6PZ0AMVAJQBWYlqw1XgdWGMAhhWOys6LnRCOlIwOPxRN2eYb3XCACAyLFjxw63290vDEpJrKc0XG2w3akC81WuJRKekhsL7EXA7XaDPQEAwEPZszcoFAoFtszVhqsjCqsluQ1rZCHNBAL2BACAkx07drhcLhWAw+VygT0BAMCze/durVZrNpu7gaWYzWatVhu+71gCewJAfJGcnJyRkTEzM+MCljIzM5ORkZEctu/3xNlzw1rqXqNkOkzjyu1bngd7AoAsOHbs2O7du6P1le2yYffu3ceOHRO1JoOw5wqvXd9TltxTdpwK43jHNrAnAAAJhmh7rl+7wmPXdZYc7Sw+2llytLPkqH60473Nz4E9AQBIKETb8+k1y922udZrh3qvJd25mnTnWtLcSNvWTc+CPQEASChE2/Op1Y+6LLMt+fub8/e3/PB5yw/7p4du//XVfwV7AgCQUIi2589WLXOYZ6q/3lP99Z6abz6p/nrPpPrmn1/6DdgTAICEQrQ91z7+iM04XZD9QUH2B4U5HxTl7tD0tGx+8R/BngAAJBSi7bn6sZ9a9FPnU949n/zuhdR389PeHepsePXf/gfYEwCAhEK0PVeteMikmzyd9Obpg2+eOfTnrw7/pb+t9qXnfgX2BAAgoRBtzyeW/71xdiJr32tZ+1478dmm7P2bVXeqX/zd/w32BAAgoRBtz8cf/YlhZjzl45dTPn4pbc8r6Xtf7bpV+R+//T/BngAAJBSi7fnYsr/Tz4wd3fnHozv/eHzXf6Z8/FLnjcp//5d/AHsCAJBQBGXP6bEjO148suPFozv/cHzXfypvVPzbb/4PsCcAAAlFuOwJx54AACQWQZ+5/4FSZ8rHL3fehDN3AAASjlD+a/Ry+ievZH76p+5bVb//1/8L7AkAQEIR5BVLJ/Ztytr3WvZnm3O/2NLbWvOHZ/8f1J4QEBAQ8R3i7EldLX/q4JunD755JunNc4ffUrfXoVfLx+7zAAAAIKoIteeTK39q0U99n7z1++R3LqS8eyHt3aHORvROTQAAgMSE055rHnvYatBePfG3qyfev3byg4LsDzQ9zZt+z/6WEAAAgMSE+zuWnnjEbpouO7O7/MzuirO7K7/aPdF/440//nOsJwwAACAJSN/v6TTPNny/r+H8vsbznzVe+Ew7ePsvL/821hMGAACQBNzfLf/koy7r3M3LX968fODWlQO3rhyYHW59+0+/i/WEAQAAJAH5d4107YWH2wuPtBcd6Sg6ote0v7NpYxYAAACQlcX9m5prVnjsuq7S43QYxjre2/xcrK8ZAAAAkAQ8v+euqkihwziu3Lbleb/f77BYICAgIBI5yPZc6bXr+ypT6TBNKLeDPSEgICB47Llupdeh769Ko8M00bl9ywtgTwgICAiSPZ8Be0JAQEBwBNgTAgICIpgAe0JAQEAEE2BPCAgIiGCCx57zYE8ICAgIXPDbU12d3l8N9oSAgIBYEoLsqa5OB3tCQEBAMAPsCQEBASEi/H5/d3e3Q7g9qfN3sCcEBESCh06nKyoqcoA9ISAgIIILEfZUV6eDPSEgIBIzmCfsos/c1dXpZrAnBAREQgZ9wi7mzL0G7AkBAQHBDrAnBAQEBGdgT9gFnrkb1DXpgQB7QkBAJFjQ5+larfbKlSsOgWfuG9at9DoM/TXp/WBPCAgIiKXB993yDn1/dVogah78zx0AAADg+V2j3srU3srU3qrUvqpU/cjNb04e3LblebHx3uvPLYnNxHidHdtef37b0u7vbt74zqaN72x6dutrjNj07DubNr67aeO7mze+u3nje5s3EsYUG9tef549Da6Wi+96eyBegICAiMv4NvugYeQm7jc1167w2vXdZck95ck95Sk9FaljbZf1wzdM40rThNI0oTSNK43jSsO40jDeYRjvMIwrjawYUxrGOgxjHfrR9gehadctiTZC6DVtzL50/exI6+xw68zQncVonR1unR1pm9O06TTt+tEOw9jiHCY6TYHo4grzZLd5stvEEebJbvNUt2UxzFPd5qke81RPoNdUtylQGXjJou2xalWBmFbZplW26V5boKCyaVU2bY9V22PVdi+JqW7rVFf4ontJaEMIxjiWqS7LZJdlsss82Wme6DQHVqwSH+OcsTRJOtAwCInRQCzJLv7ooMIw9iBJqPQwTwY2sZWxBRc3X3hDFb0IvJEeq7bHSuXwZLd5siuwUzA2hKB1jgR282EClQO15oMOrqwTH2ZSdJLDMHJzsv0K054+p+GZdSsVv/zlL78+c7K/4VxH8dHOkmNdpcd7ypJ7ylO6y5N7ypJ7ypO7y5K7So93lhxTlhztLDnaWXq0s/RYVxn188XHOkuOdZYcUxYfbS860lZ4uPVa0p1rB29fPXjrysGblw8sjS9vXv7y5iV23Lp84PaVA3euHmwtSGotSLpz7eCdqwdvXT5w49KXzfn7G85/Vvfdp7Xf7q39bm/tt5/Wffdp/fnPmvO/uH75wK2rSa0Fh9sKj7YXHe0oPq4sOa4sSVaWJHeUJCtLkjtLUjpLUzrLUjrLUrrKU7vKU7sr0gJRntbFiO7ytJ6K9J7KjN6qjL7qzL7qzN7qzN6qwKOqKlNVmdFTmdFTmaGqzFBVZfZWZfbVZKlrTwzUZw815Aw35o405Wma80Zb8sZaTo025402540254425Yw25WgaszWNJzWNJzUNJ0YaskYaskbqs0bqM8MXWQ+igR2ahhO8MRKIwNyG67OG6zKH6jIHazMGa9IHatKpdOmvSqVj8QcEU6joraAjmRmqimRVeSB6qCg7zopuKkqPd5ce7yo9ho+SY10lgUzrpJKw5Ghn8VEld3QWH6Xad5Ue6yo93l2W3FOe0luZ1leVrq7JHKjNGqw7MVR/crghZ6QxV9OUu7jV8kZbTo2FL0Zb8gRFc+iRq2nK1TTmjDRmDzdkD9WfHKw7MVCbqa7J6K9K761MVVWkqMpTVOUpPeXJ9DrnWuHdpYvbhRHotsNE+YMtviSWJgZHpKBB5xgSqcyEFBhqrmBoUUiM3fr+m7PZv/zlLxVvvfXWhqeenNN03L6a1HrtUHvhkY7io0o6U0uPKUuOKouPtBcebi041FZwqL3wcEfRYWXxEWXxkY7iI+2Fh9sKD7cWHLpz9eDNyweuX/yi5Yf9zfmfN134vPHCZ4E4/1nj+c8avt/X8P2nDd9/Wv/9pw0PYl/j+X1NFz5v/uHz6xf3X7+4P9A9/7P67/dVf7On/Ozu4rydRbkfFuXuLMrbWZz3YenpXZVf7an5dm/D+c8b879ovvjl9csHb1xOunk56caVpJtXkm5eTrp5OenmlUM3rx66efXQrauHb187fKfgaGvhsbbCY22Fx1oLj7UWHm0tPNpaeKy16Fhb0fH24uMdpSmdZandFendFeld5WmdZWmdZanK0pSOkpT2kuT24uT24uT2kuSOklRlaVpXeXpPZUZfddZA3cnBhuyhxtyRpgf7Hl6gAVVFWKCIQwULlGHP+qzh+iyWQFmJyGFPPoHidrkHuyiXPbkEWkIU6GJ72p6qilRUoCONOZqmXM0DDYXTnkIdGg57jjaxBHpisC5roDZTXZ3RV5XWW5mqqkhVVaRQW4G8woO3Z0gCxdiT4ND+8ApUjEMtU90/f3rNc889p1AoFD978tFzp7OHWouvX/ry5uWDlEbbCg63FR5uLzrSVnio9VoSfSx5+8rBO9eSWgsOtRYk3bmWdPvqwVtXDty4/GXLxf1N+Z83nN9X9+2nNd/srfnmk6pze6rOfVx57uPKr6jYXfHV7oozu8vP7GJGxdndVV9/XPvtJ3XffVr33ae1335a+83emm8+qTi7qzj3w6sn/nYxY9uF1Pfy097LT9t2IfW9ixn/de3kjqJTO8vPflx5bk/V13trvvm09rvP6Kj5dl/Nd5/VfvdZ3Xef1X3/ef33+xsufNGU/2XzDwebLx1svnig+eKBposHmi4ebL54sOVSUsulpBtXDt26duROwbG2ouNtRcdbC4/dKTh669qRm1eP3Lxy+ObVwzeuHL5x5fDNq0duXTt6u+BYW9HxjtLU7or03upM6iB0uGHxEIbaWxgCZR5+BgQaRXsKEegDezZkjTTg7amuTlNXpcXWngyH8ttTWUy1wQi0v3pRoPUnhxuyAwINHIHGwp7hEejiEWhTzkhjzkhD9jB9BFqd0VeV3luZ2lOesngSkExe4d2lx1CBCnJoSIefET8CDd2es301336V+8y6la+++qoiLS1NoVA88tB/++r0Se1Qa0dVXsvFL25cOnDz8oFbVw7evhrw5vWLXzb/sL85f3/LxS9uXPqSMumNS1+2XPyi+YfPGy98Vv/dp5QxK87uLjuzq/T0RyV5O4vzPizK/bAod0dhzo7CnA8Ksj+4lv3+tZPvXz3x/pUTf6Pi2sn3i3J3lJzaScm07MyustO7Sk9/VJSz43LWf51Peffro2+dPfTns4f+QsXXR/96PuVdyqEFOR8W5e4sPrWr5PTu0tMfl5zaXXxqV3HerqK8XUV5u4pP7So+vbv0zMflX31ScW5v1Tf7ar7dV/3NvupvPqMea779vPa7z+u+399w4cumHw60XEq6ceXwzSuHr19Oarl0sOmHg435BxoufFl/4cu681/Unf+iIf/Lph8ONl9MunHl8J3CY+2lKV3l6b1VmeraE4MN2SONeYFDmKX25D5/D6NDSfYU4lDW+fvIEoFmBARaFcwRKFOgXA5lCJT7/L0UY0++w8+ji42XCLSvKr2/OoNx/h4QaCzP3yNhz4aTQ/UnBmuz1DUZ/dXpi0eggfP3RYHiV3jw9iQ6NNwCjerh59it7y1T3d9+lbv8kZ+8+OKLH330keLs2bMKhWLbtm1rn3jk6XWrzuZmOi2zVLgssy7LnGvxqdM8S7/kZFQ6zDMO84zdNGM3TduMdGitBmZMWQxTFv2DMOunzLops26Semo1TAVaGrU2o9Zm1FoNUxb9lEk3aZydMM6OP3icmzDNTZp1Uxb9lMWgtSxZitZi0Fr0i/HgVebEZmymQNipMM84zLOOwLubo4KqocJunrGbZ+x0jWXWaZlzWXVum85j13vseq/DMO8wzDuNPjpcjPKDMMgo5p2GeQcdejq8zLAHHTo0PLxhCyECgyxOwKF/8O6cS7cdtfmiHJhsCTXmnUbmRkS3F/8KxwV22yERSm6IDIe4mA82vjmT/fOn1zyzbuWLL764Y8eO/fv3K1isfeKRdU88sm7VsnWrlv2MEetWLVu3il2/btWydU88svaJR9Y+8ciaxx9e8/jDqx97ePVjP6XjyZV0PLRq5UOrVjy0asVDT6z4+yeWLwmq/smVD1GNV68M9F214qEnlv/9Y4/+5LFlf0fFymV/99iyv3v80Z88TvVd8fes0R5/9CdoMJfCDGqJ1OJWP/Yw9RYW3whr/j99MtDsp1SDtU88sm7Vsp89ueypJx99evXyp9csX79mxYa1dKzcsG7lhnUrn4GAgIiXePbZZ19++eWdO3fu378/OTn5/wfnUSC/j4H5KQAAAABJRU5ErkJggg==" alt="" />   那么什么又是线程呢?              线程其实就是进程的最小工作单位。是进程中一个负责程序执行的控制单元(执行路径), 一个进程中可以多执行路径,称之为多线程。   一个进程成至少要有一个线程。  在JAVA中开启多线程的目的是什么?    就是为了同时运行多部分代码,提高工作效率。    而每一个线程都有自己运行的内容,这个内容可以称为线程要执行的任务。    其实应用程序的执行都是cpu在做着快速的切换完成的,这个切换是随机的,即所有应用程序在运行的过程中都在争夺cpu的执行权,谁拿到这个执行权那么谁就执行相应的代码,执行自己要执行的任务。   在JVM启动时,就启动了多个线程,即便是最简单的代码,我们也能够直观的分析出两个线程 1,执行main函数的线程。                 该线程的任务代码都定义在main函数中 2,负责垃圾回收的线程。   二、创建线程   创建线程方式一:继承Thread类 步骤: 1,定义一个类继承Thread类 2,覆盖Thread类中的run方法。         创建线程的目的是为了开启一条执行路径,去运行指定的代码和其他代码实现同时运行。       而运行的指定代码就是这个执行路径的任务。       jvm创建的主线程的任务都定义在了主函数中。  而自定义的线程它的任务哪里呢?         Thread类用于描述线程,线程是需要任务的,所以Thread类也有对任务的描述。         这个任务就通过Thread类中的run方法来体现。也就是说,run方法就是封装自定义线程任务的函数。           run方法中定义的就是线程要运行的任务代码。           开启线程是为了制定代码,所以只有继承Thread类,并复写run方法。         将运行的代码定义在run方法中即可。  简单代码示例:
     1 public class ExtendsThreadDemo {
     2 
     3     public static void main(String[] args) {
     4         Student s1 = new Student();
     5         Student s2 = new Student();
     6         s1.start();
     7         s2.start();
     8         
     9     }
    10 
    11 }
    12 
    13 class Student extends Thread{
    14     public void run(){
    15         while(true){
    16         System.out.println(Thread.currentThread().getName()+".....student study!!!");
    17     }
    18     }
    19 }
    3,直接创建Thread类的子类对象创建线程。 4,调用对象的start方法开启线程并调用线程的任务run方法执行。   补充:可以通过Thread的getName获取线程的名称 : Thread-编号(从0开始)主线程的名字就是main    调用run和调用start有什么区别?       调用run与调用一个方法是相同的,而调用start是调用一个线程来执行run方法。     创建线程的第二种方式:实现Runnable接口   1,定义类实现Runnable接口。 2,覆盖接口中的run方法,将线程的任务代码封装到run方法中。 3,通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。     原因是线程的任务都封装在Runnable接口子类对象的run方法中。所以要再线程对象创建时就必须明确要运行的任务。 4,调用线程对象的start方法开启线程。 简单代码示例:
     1 public class ImplementsRunnableDemo {
     2 
     3     public static void main(String[] args) {
     4         Student s1 = new Student();
     5         Thread t1 = new Thread(s1);
     6         Thread t2 = new Thread(s1);
     7         t1.start();
     8         t2.start();
     9         
    10     }
    11 
    12 }
    13 
    14 class Student implements Runnable{
    15     public void run(){
    16         while(true){
    17         System.out.println(Thread.currentThread().getName()+".....student study!!!");
    18     }
    19     }
    20 }
    实现Runnable接口的好处:     1,将线程的任务从线程的子类中分离出来,进行了单独的封装。         按照面向对象的思想将任务封装成对象。     2,避免了java单继承的局限性。 所以,创建线程的第二种方式较为常用。   线程安全问题产生的原因:   1,多个线程在操作共享的数据。   2,操作共享数据的线程代码有多条。   当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算,就会导致线程安全问题的产生。   解决思路: 就是将多条操作共享数据的线程代码封装起来,当有线程在执行这些代码的时候,其他线程是不可以参与运算的。必须要当前线程把这些代码都执行完毕后,其他线程才可以参与运算。   在java中,用同步代码块就可以解决这个问题。 同步代码块的格式:     synchronized(对象){         需要被同步的代码; }   同步的好处:     解决了线程的安全问题。 同步的弊端:     相对降低了效率,因为同步外的线程都会判断同步锁。判断后还不能执行,相当于进行的是无效判断。   同步的前提:         同步中必须有多个线程并使用同一个锁。   同步函数 格式:    public synchronized void 函数名( ){   } 注:同步函数的锁是this   同步函数和同步代码块的区别:     同步函数的锁是固定的this     同步代码块的锁是任意的对象 在开发中,建议使用同步代码快,同步函数可以作为同步代码快的简写形式。   静态的同步函数 格式:    public static synchronized void 函数名( ){   } 静态的同步函数使用的锁是该函数所属的字节码文件对象,可以用getClass方法获取,也可以用 当前类名.class 形式表示   三、多线程下的单例设计模式   饿汉式     饿汉式的写法比较安全和高效,也是我们在开发过程中常用的写法。 代码示例:
        class Single
    {
        private static final Single s = new Single();//类加载的时候就创建了s,不会有争执和分歧
        private Single(){}
        public static Single getInstance()
        {
            return s;
        }
    }
    懒汉式 原写法:
        class Single
    {
        private static Single s = null;
        private Single(){}
        public static Single getInstance()
           {
                if (s == null)
                    s = new Single();
    
                   return s;
            }
    }

    多线程写法:

        class Single
    {
        private static Single s = null;
        private Single(){}
        public static Single getInstance()
           {
            if(s == null){    //解决效率问题
                syncchronized(Single.class) {  //解决安全问题 
               if (s == null)
                    s = new Single();
                   return s;
            }
           }
    }
    }

    四、死锁

     常见情景之一就是同步之间的嵌套。 示例代码如下:
    class DeadLock
    {
     public static void main(String[] args)
     {
      Demo d1 = new Demo(true); 
      Demo d2 = new Demo(false);
      Thread t1 = new Thread(d1);
      Thread t2 = new Thread(d2);
      t1.start();
      t2.start();
      System.out.println(Thread.currentThread().getName()+"........"+"over");
     }
    }
    
    
    class Demo implements Runnable
    {
     private  boolean flag;
     Demo(boolean flag){
      this.flag = flag;
     }
    
     public void run()
     {
      if(flag)
      {
       while(true)
        {
       synchronized(MyLock.lock2){
        System.out.println("aaaaaa111111锁"+Thread.currentThread().getName());
        synchronized(MyLock.lock1){
        System.out.println("aaaaaa222222锁"+Thread.currentThread().getName());
        }
       }
       }
      }
      else{
       while(true)
        {
      synchronized(MyLock.lock1){
        System.out.println("bbbbbbb111111锁"+Thread.currentThread().getName());
        synchronized(MyLock.lock2){
        System.out.println("bbbbbbbb222222锁"+Thread.currentThread().getName());
        }
       }
       }
      }
     }
    }
    
    class MyLock
    {
     public static final Object lock1 = new Object();
     public static final Object lock2 = new Object();
    }

    五、线程间的通讯:         个人理解:多个线程在处理同一资源,但是任务却不同。   等待和唤醒机制     涉及的方法:         1,wait();                    :让线程处于冻结状态,线程会释放cpu的执行权和执行资格,被wait的线程会被存储到线程池中。         2.notify();                 :用于唤醒线程池中的一个线程(任意的,无顺序)。         3,notifyAll();                 :用于唤醒线程池中的所有线程。让线程具备了执行资格,处于运行状态或线程阻塞状态。   这些方法都必须定义在同步中,因为这些方法是用于操作线程状态的方法。必须要明确到底操作的是哪个锁上的线程。可以理解为以锁来标记线程池。   为什么操作线程的方法wait () notiry() notifyAll()定义在了Object类中,而没有定义在Thread类中?         因为这些方法是监视器的方法,监视器其实就是锁,锁可以是任意的对象,任意的对象调用的方法一定定义在Object类中。   等待唤醒机制的经典案例:生产者与消费者 单生产者与单消费者代码示例:
    public class ProducerAndConsumer {
    
     public static void main(String[] args) {
      Goods g = new Goods();
      Producer p = new Producer(g);
      Consumer c = new Consumer(g);
      Thread t1 = new Thread(p);
      Thread t2 = new Thread(c);
      t1.start();
      t2.start();
     }
    
    }
    class Goods{
     private String name;
     private int count = 1;
     private boolean flag = false;
     public synchronized void set(String name){
      if(flag){
       try {
        this.wait();
       } catch (InterruptedException e) {}
      }
      this.name = name + count;
      count++;
      System.out.println(Thread.currentThread().getName()+"--生产--"+this.name);
      flag = true;
      notify();
     }
     
     public synchronized void out(){
      if(!flag){
       try {
        this.wait();
       } catch (InterruptedException e) {}
      }
      System.out.println(Thread.currentThread().getName()+"--消费--------"+this.name);
      flag = false;
      notify();
     }
    }
    
    class Producer implements Runnable{
     private Goods g;
     Producer(Goods g) {
      this.g = g;
     }
     public void run(){
      while (true) {
       g.set("馒头");
      }
     }
    }
    
    class Consumer implements Runnable{
     private Goods g;
     Consumer(Goods g) {
      this.g = g;
     }
     public void run(){
      while (true) {
       g.out();
      }
     }
    }

    多生产者与多消费者   if判断标记,只有一次,会导致不该运行的线程运行了,出现了数据错误的情况。while判断标记,解决了线程获取执行权后,是否要运行!   notify:只能唤醒一个线程,如果本方唤醒了本方,没有意义,而且while判断标记+notify会导致死锁 notifyAll解决了本方线程一定会唤醒对方线程的问题。   代码示例一:
    public class ProducerAndConsumer {
    
     public static void main(String[] args) {
      Goods g = new Goods();
      Producer p = new Producer(g);
      Consumer c = new Consumer(g);
      Thread t0 = new Thread(p);
      Thread t1 = new Thread(c);
      Thread t2 = new Thread(p);
      Thread t3 = new Thread(c);
      t0.start();
      t1.start();
      t2.start();
      t3.start();
     }
    
    }
    class Goods{
     private String name;
     private int count = 1;
     private boolean flag = false;
     public synchronized void set(String name){
      while(flag){
       try {
        this.wait();
       } catch (InterruptedException e) {}
      }
      this.name = name + count;
      count++;
      System.out.println(Thread.currentThread().getName()+"--生产--"+this.name);
      flag = true;
      notifyAll();
     }
     
     public synchronized void out(){
      while(!flag){
       try {
        this.wait();
       } catch (InterruptedException e) {}
      }
      System.out.println(Thread.currentThread().getName()+"--消费--------"+this.name);
      flag = false;
      notifyAll();
     }
    }
    
    class Producer implements Runnable{
     private Goods g;
     Producer(Goods g) {
      this.g = g;
     }
     public void run(){
      while (true) {
       g.set("馒头");
      }
     }
    }
    
    class Consumer implements Runnable{
     private Goods g;
     Consumer(Goods g) {
      this.g = g;
     }
     public void run(){
      while (true) {
       g.out();
      }
     }
    }

    jdk1.5以后将同步和锁封装成了对象,并将操作锁的隐式方式定义到了该对象中,将隐式动作变成了显式动作 Lock接口:出现替代了同步代码块或者同步函数,将同步的隐式锁操作编程了显式锁操作,同时更为灵活,可以一个锁上加上多组监视器           lock():获取锁         unlock():释放锁,通常需要定义finally代码块中。 Condition接口:出现替代了Object中的wait / notify  / notifyAll 方法                     将这些监视器方法单独进行了封装,变成了Condition监视器对象。                     可以和任意锁进行组合。 await(); signal(); signalAll();     代码示例二:
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ProducerAndConsumer {
    
     public static void main(String[] args) {
      Goods g = new Goods();
      Producer p = new Producer(g);
      Consumer c = new Consumer(g);
      Thread t0 = new Thread(p);
      Thread t1 = new Thread(c);
      Thread t2 = new Thread(p);
      Thread t3 = new Thread(c);
      t0.start();
      t1.start();
      t2.start();
      t3.start();
     }
    
    }
    class Goods{
     private String name;
     private int count = 1;
     private boolean flag = false;
     
     Lock lock = new ReentrantLock();
     
     Condition c1 = lock.newCondition();
     Condition c2 = lock.newCondition();
     
     public  void set(String name){
      lock.lock();
      try{
      while(flag){
       try{c1.await();
       } catch (InterruptedException e) {}
      }
      this.name = name + count;
      count++;
      System.out.println(Thread.currentThread().getName()+"--生产--"+this.name);
      flag = true;
      c2.signal();
     }finally{
      lock.unlock();
     }
     }
     
     public  void out(){
      lock.lock();
      try{
      while(!flag){
       try {c2.await();
       } catch (InterruptedException e) {}
      }
      System.out.println(Thread.currentThread().getName()+"--消费--------"+this.name);
      flag = false;
      c1.signal();
    
      }				
About IT165 - 广告服务 - 隐私声明 - 版权申明 - 免责条款 - 网站地图 - 网友投稿 - 联系方式
本站内容来自于互联网,仅供用于网络技术学习,学习中请遵循相关法律法规